javaarray
① java数组(初学者）
当你建立数组 a[] b[] 后 各自分配了一个内存地址, 假设a[] 的是A(这是段0和1组成的代码) A里边存放的是100,200,300
当你在程序中调用a[],程序会先找到A,然后用里边的东西所以例如:a[0]=100
b[]的是B(同上)
B里存放的是 10,11,12,13,14,15,16
b[0]=10
当你b=a时,b的内存地址不再指向B而是指向A了,于是它里边的东西就跟a[]的一样了,故b[0]=100了
比喻:
a,b都是钥匙
a可以打开A房间 里边放了 100...
b可以打开B房间 里边放了10,11...
现在改造了 b=a
就是把b要是改成了跟a一样的钥匙,所以它不能再开B房间,只能开A房间，大小内容跟a一样了
你要是不给我分,我也彻底无语了，我可是认真敲出来的答案
② java里的array是什么意思
Java中没有array，只有Arrays这个类
此类包含用来操作数组（比如排序和搜索）的各种方法。此类还包含一个允许将数组作为列表来查看的静态工厂。
③ JAVA数组
这个程序为了易删除，并没有采用数组，而采用了双向链表
链表中的元素是结点Kid，Kid有一个左结点，一个右结点，左结点指向上一个Kid，右结点指向下一个Kid。这些在构造函数中完成的，其中first是第一个结点，last是最后一个结点。
这样就把500个孩子串成一条链，并且这是一个环状的链，你画个图就明白了。
这样删除起来就方便了，如果要删一个结点
这个结点的左结点的右结点=这个结点的结节点
这个结点的右结点的左结点=这个结点的结节点
---------------------------------------------------------------
具体讲讲add的算法，你准备一张纸，在上面画就能理解：
每个孩子的编号id设为count，然后把这个孩子往链表里添
如果目前没有链表，即孩子数量为0，则创建链表，链头是first，链尾是last
1.添加一个孩子，这个孩子是这个链表的链头first，也是链尾last，即first=last=k;
2.由于没有其他结点，这个结点的左结点就是自己，右结点也是自己，即k.left=k.right=k;
如果目前已经有链表，则
1.添加新结点到链尾的下一个，即last.right=k;，
2.新结点的左结点是之前的链尾，即k.left=last;
3.由于是一个环形的链，新结点的右结点链头k.right=first;
4.由于是一个环形的链，链头的左结点是新结点first.left=k;
5.新结点是新链的链尾last=k;
6.链头不变
④ java array
在一个死循环里while(true),输一个数字,判断一下是不是99,不是就往数组的末尾加,是就break,然后输出整个数组,试试吧,应该能做出来的.输入是System.in
⑤ java 数组
对与你的这个程序算法也没什么复杂的。我也就不用解释了。关于你提出的问题我说一下：
1. 修改array2时array1当然要发生变化了。之所以你对这个有疑问，是你对java中的数据类型还没理解。在java中有两中数据类型，值类型和引用类型。像一些基本的数据类型如：int ,float,double,byte等都是值类型，而String,还有‘类’都是引用类型，其中数组也是引用类型。
array2=array1; 这句话就是把array1的首地址赋值给array2，此时array1和array2所指向的是同一块类存单元。array2对这块内存的修改也会反映在array1上了。
同样的道理，当向一个函数传值时，如果函数的形参是一个值类型的数据，则在传参数时把实参的内容拷贝一份放到形参里面，之后形参在函数相当于一个局部变量，它在函数中做的一切动作都不会影响到实参的内容。
而如果函数的形参是一个引用类型，当向它传值时，就是把实参的地址传给形参，而不是把它的内容传给形参。这时候形参有了实际参数的内存地址，那么在函数中形参的改变也会反应到实际参数中来，你可以做下列实验：
//test1.java
class test1
{
public static void main(String [] args)
{
int [] b={9,8,7,6,5,4,3,2,1,0};
int c=10;
test2.amend(b);
test2.print(b);//输出：0 1 2 3 4 5 6 7 8 9说明b的值被改了。
System.out.println(""); //换行
test2.amend1(c);
System.out.println(c); //输出：10 说明c的值并没有被改为20
}
}
class test2
{
public static void amend(int [] a) //引用传递
{
for(int i=0;i<a.length;i++)
a[i]=i;
}
public static void print(int [] a)
{
for(int i=0;i<a.length;i++)
System.out.print(a[i]+" ");
}
public static void amend1(int a)
{
a=20;
}
}
引用就相当于c语言里面的指针，不知道你学过c语言没有。如果学过，就应该很容易理解的。java中没有指针的概念，在java中是不允许直接操作变量的内存地址的。
int a=10;
int b=a; //这里仅仅是把a的值，也就是10拷贝一份再赋给变量b。a和b在内存上是没有任何联系的。
如果Student是一个类，那么：
Student stu1=new Student(); //学生1
Student stu2=stu1; //把学生1的引用赋给学生2这时候stu2的操作就会反映到stu1上。
参考下面的例子：
class test1
{
public static void main(String [] args)
{
Student stu1=new Student("张三",18); //建立一个学生变量，并且初始化为"张三" ,18岁 Student stu2=stu1; //把学生stu1的引用赋给学生stu2
stu1.print(); //输出：名字:张三 年龄:18
stu2.print(); //输出：名字:张三 年龄:18
//把学生stu2的名字改成"李四" 20岁
stu2.name="李四";
stu2.age=20;
stu1.print(); //输出名字:李四 年龄:20
stu2.print(); //输出名字:李四 年龄:20
}
}
class Student
{
String name; //学生的名字
int age; //学生的年龄
Student(String name,int age)
{
this.name=name; //给名字赋值
this.age=age; //给年龄赋值
}
void print() //输出学生的名字和年龄
{
System.out.println("名字:"+name+" 年龄:"+age);
}
}
//可以看到，我改了stu2的名字和年龄，但是stu1学生的名字和年龄也改了。这就是引用的效果。
2.第二个问题：This method has a constructor name
这句话的意思说，"这个方法有一个构造函数名字"
为什么会出现这样的提示呢？是因为你定义的类的名字是：printArray，而这个类默认有一个构造函数它的名字是和类名相同的。而且构造函数是没有返回值的。
而你在类里面有定义了一个public 的静态的成员方法。
它的名字和你的构造函数的名字是一样的。如果你把static void 都去掉的话，也就是说变成这种形式：
public printArray(int [] array)
{
}
那么这时系统就会把它当作是类的构造函数了，但是你这里函数的形式是：
public static void printArray(int [] array)
{
}
因为有返回值所以，系统把它当作是类的成员函数了，但是它又是与构造函数的名字相同的，所以就出现了你上面的警告了。虽然没有报错，但还是希望类的成员函数不要与类的名字相同，以免带来不必要的麻烦。
我的回答也只有这些了，相信你对java里面的数据类型也有了一个了解了吧，如果还有不懂的话，上网络去吧。。
⑥ Java数组
public static void main(String[] args) {
int[] arr=new int[10];
for(int i=0;i<arr.length;i++){
arr[i]=(int)(Math.random()*10);
}
for(int n :arr){
System.out.println(n);
}
int arrMax=0,arrMin=0;
arrMax=arr[0];
arrMin=arr[0];
for(int i=0;i<arr.length;i++){
if(arr[i]>arrMax){arrMax=arr[i];}
if(arr[i]<arrMin){ arrMin=arr[i];}
}
System.out.println("最大值---"+arrMax+"\n"+"最小值---"+arrMin);
for(int i=0;i<arr.length;i++){
for(int j=0;j<arr.length-i-1;j++){
if(arr[j]>arr[j+1]){
int num=arr[j];
arr[j]=arr[j+1];
arr[j+1]=num;
}
}
}
for(int n :arr){
System.out.println(n);
}
} 记得采纳哦
⑦ 请问Java中的Array是怎么使用的
Array就是阵列，磁盘阵列模式是把几个磁盘的存储空间整合起来，形成一个大的单一连续的存储空间。NetRAID控制器利用它的SCSI通道可以把多个磁盘组合成一个磁盘阵列。简单的说，阵列就是由多个磁盘组成，并行工作的磁盘系统。需要注意的是作为热备用的磁盘是不能添加到阵列中的。
⑧ java中arrays的用法
如果你问的是API的话，要注意，Java中是区分大小写的，不存在arrays这么个类，而是Arrays，
并且全称是java.util.Arrays，其文档可在 http://download.oracle.com/javase/6/docs/api/ 参考，搜索Arrays你就找到了，不要惧怕英文，耐心看一下就搞明白了。
如果是问的数组(array)，那么：
第一，在Java中，数组是一种专门的类型，它是有序数据的集合，数组中的每个元素的数据类型都是相同的。
第二，对元素的确定是由数组名和它的下标实现的，这是和C/C++中的一样的，比如a[0]代表数组a的第一个元素，a[1]代表数组a的第二个元素，依次类推。
第三，得说说数组的声明方法，Java的数组声明采用与C语言类似, 数组可分为一维数组和多维数组。声明形式为： type arrayName [] [[]...]; 或：type [] [[]...] arrayName; 后边这种方式是Java比较独特的地方, 体现了Java的纯面向对象的特征。
第四，Java数组声明中，不需要指明数组大小，这是因为数组声明并未为数组元素分配存储单元，要为数组元素分配存储单元，必须显示使用new运算符实现，这里就和C/C++有很大不同了。格式是： arrayName[][[]...] = new type [Size1][[Size2]...];
第五，声明数组与为数组分配存储单元两部分，可以合在一起；上面举例的就是和在一起的形式。如果要分开，就是写两成两句：int numbers[]; numbers = new int[10]; 这看起来和C++很相似。
第六，对已经分配了存储空间的数组(由new运算符实现)，就可以对数组中的每一个元素引用。下标是放在数组名后面[]中的，通过对下标的操作来引用元素。我们可以赋值给元素，也可以使用元素的值，主要下标是从0开始的。
第七，Java中，对于每一个数组，都有一个属性length，来指明数组的长度，这对于写程序就很方便了。int count[] = new int [10]; 包括count[0] count[1] ... count[9] 那么 count.length = 10
第八，在声明数组时，也可以同时对数组进行初始化。它的一维形式如下：
type arrayName[] = {Value1, Value2, ... , ValueN};
例如：
float myf[] = {1,2,3,4,5,6}
int myint[][]={{1,2,3},{4,5,6}};
//int myint[][]=new myint[2][3];
与C或C++语言不一样，Java对数组元素的下标要进行越界检查，以确保数据的安全。
记住这8条，我相信你对数组就基本都掌握了。
好了，希望对你有所帮助，有问题随时联系我:)
⑨ 关于JAVA数组
运行后信息输出到C:\123.txt这个文件,有不明白就 Email: [email protected]
Test.java
import java.io.FileNotFoundException;
import java.io.PrintWriter;
import java.text.DecimalFormat;
public class Test {
/**
* @param args
*/
public static void main(String[] args) {
PrintWriter pw = null;
/**
* 1 表示把输出到c:\123.txt 其余情况输出到控制台
*
* @param i
* @return
*/
int method = 1;
pw = createPW(method);
/**
* 创造一个二维数组，数组的行代表层数，数组的列代表房间号。
*/
float[][] a = create2DimArray(30, 20);
/**
* 用一个嵌套循环，把基础房间价格放在每层的每间房里。
*/
setDefualt(a, 150);
/**
* 用一个巢状循环(不知道什么是巢状循环,用for嵌套代替吧)，把每层每间的基础价格显示（打印）出来。
*/
pw.write("初始房间价格列表：");
pw.write("\r\n");
print2DimArray(a, pw);
pw.write("============================================================================分割线================================================================");
pw.write("\r\n");
/**
* 用一个嵌套循环，根据上面的BCDE的条件来调整每层的房间价格。
*
* B.靠沙滩（房间6~11）+$100
*
* C.从侧面能看到海的房间每间（房间1~5,12~16）+$50
*
* D.四个角落的大房间（房间1,6,11,16）每个+$100
*
* E顶层（30层）+$100
*/
modifyPrice(a);
/**
* .用一个嵌套循环，把每层每间的调整过后的房价显示出来。形式是，房间号FRR，和价格 $XXX.XX
*/
pw.write("更新后房间价格列表：");
pw.write("\r\n");
print2DimArray(a, pw);
pw.flush();
/**
* 如果输出到文件流的话，还要关闭对应的输出流，控制台输出就不用关闭了
*/
if (method == 1) {
pw.close();
}
}
/**
* 1 表示把输出到c:\123.txt 其余情况输出到控制台
*
* @param i
* @return
*/
private static PrintWriter createPW(int i) {
PrintWriter pw = null;
switch (i) {
case 0: {
pw = new PrintWriter(System.out);
break;
}
case 1: {
try {
pw = new PrintWriter("c:\\123.txt");
} catch (FileNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
break;
}
default: {
pw = new PrintWriter(System.out);
break;
}
}
return pw;
}
/**
* 用一个嵌套循环，根据上面的BCDE的条件来调整每层的房间价格。
*
* B.靠沙滩（房间6~11）+$100
*
* C.从侧面能看到海的房间每间（房间1~5,12~16）+$50
*
* D.四个角落的大房间（房间1,6,11,16）每个+$100
*
* E顶层（30层）+$100
*/
private static void modifyPrice(float[][] a) {
for (int i = 0, k = a.length; i < k; i++) {
float[] b = a[i];
for (int m = 0, n = b.length; m < n; m++) {
b[m] = modifyPrice(b[m], i, m);
}
}
}
private static float modifyPrice(float value, int i, int m) {
int a = i + 1;
int b = m + 1;
if (b > 6 && b <= 11) {
value += 100;
} else if ((b > 1 && b <= 5) || b > 12 && b < 16) {
value += 50;
} else if (b == 1 || b == 16) {
value += 150;
} else if (b == 6 || b == 11) {
value += 200;
}
if (a == 30) {
value += 100;
}
return value;
}
/**
* 用一个巢状循环(不知道什么是巢状循环,用for嵌套代替吧)，把每层每间的基础价格显示（打印）出来。
*/
private static void print2DimArray(float[][] a, PrintWriter pw) {
if (pw == null) {
print2DimArray(a);
}
String s;
float[] b;
DecimalFormat df = new DecimalFormat(".00");
for (int i = 0, k = a.length; i < k; i++) {
b = a[i];
for (int m = 0, n = b.length; m < n; m++) {
s = "房间号:" + (i < 9 ? " " : " ") + (i + 1)
+ (m < 9 ? "0" : "") + (m + 1) + ",";
s += "价格$" + df.format(b[m]) + " ";
pw.write(s);
}
pw.write("\r\n");
}
}
/**
* 用一个巢状循环(不知道什么是巢状循环,用for嵌套代替吧)，把每层每间的基础价格显示（打印）出来。
*/
private static void print2DimArray(float[][] a) {
for (int i = 0, k = a.length; i < k; i++) {
float[] b = a[i];
for (int m = 0, n = b.length; m < n; m++) {
System.out.printf("房间号:" + (i < 9 ? " " : " ") + "%d"
+ (m < 9 ? "0" : "") + "%d,价格:$%#.2f ", i + 1, m + 1,
b[m]);
}
System.out.println("");
}
}
/**
* 用一个嵌套循环，把基础房间价格放在每层的每间房里。
*/
private static void setDefualt(float[][] a, float value) {
for (int i = 0, k = a.length; i < k; i++) {
float[] b = a[i];
for (int m = 0, n = b.length; m < n; m++) {
b[m] = value;
}
}
}
/**
* 创造一个二维数组，数组的行代表层数，数组的列代表房间号。
*/
private static float[][] create2DimArray(int i, int j) {
float[][] a = new float[i][i];
return a;
}
}
⑩ java数组
数组是有序数据的集合，数组中的每个元素具有相同的数组名和下标来唯一地确定数组中的元素。
§5.1一维数组
一、一维数组的定义
type arrayName[];
其中类型(type)可以为Java中任意的数据类型，包括简单类型组合类型，数组名arrayName为一个合法的标识符，[]指明该变量是一个数组类型变量。例如：
int intArray[];
声明了一个整型数组，数组中的每个元素为整型数据。与C、C++不同，Java在数组的定义中并不为数组元素分配内存，因此[]中不用指出数组中元素个数，即数组长度，而且对于如上定义的一个数组是不能访问它的任何元素的。我们必须为它分配内存空间，这时要用到运算符new，其格式如下：
arrayName=new type[arraySize];
其中，arraySize指明数组的长度。如：
intArray=new int[3];
为一个整型数组分配3个int型整数所占据的内存空间。
通常，这两部分可以合在一起，格式如下：
type arrayName=new type[arraySize];
例如：
int intArray=new int[3];
二、一维数组元素的引用
定义了一个数组，并用运算符new为它分配了内存空间后，就可以引用数组中的每一个元素了。数组元素的引用方式为：
arrayName[index]
其中：index为数组下标，它可以为整型常数或表达式。如a[3]，b[i](i为整型)，c[6*I]等。下标 从0开始，一直到数组的长度减1。对于上面例子中的in-tArray数来说，它有3个元素，分别为：
intArray[0]，intArray[1]，intArray[2]。注意：没有intArray[3]。
另外，与C、C++中不同，Java对数组元素要进行越界检查以保证安全性。同时，对于每个数组都有一个属性length指明它的长度，例如：intArray.length指明数组intArray的长度。
例5.1
public class ArrayTest{
public static void main(String args[]){
int i;
int a[]=newint[5];
for(i=0;i＜5;i++)
a[i]=i;
for(i=a.length-1;i＞=0;i--)
System.out.println("a["+i+"]="+a[i]);
}
}
运行结果如下：
C:\＞java ArrayTest
a[4]=4
a[3]=3
a[2]=2
a[1]=1
a[0]=0
该程序对数组中的每个元素赋值，然后按逆序输出。
三、一维数组的初始化
对数组元素可以按照上述的例子进行赋值。也可以在定义数组的同时进行初始化。
例如：
int a[]={1，2，3，4，5};
用逗号(，)分隔数组的各个元素，系统自动为数组分配一定空间。
与C中不同，这时Java不要求数组为静态(static)。
四、一维数组程序举例：
例5.2Fibonacci数列
Fibonacci数列的定义为：
F1=F2=1，Fn=Fn-1+Fn-2(n＞=3)
public classFibonacci{
public static void main(String args[]){
int i;
int f[]=new int[10];
f[0]=f[1]=1;
for(i=2;i＜10;i++)
f[i]=f[i-1]+f[i-2];
for(i=1;i＜=10;i++)
System.out.println("F["+i+"]="+f[i-1]);
}
}
运行结果为：
C:\＞java Fibonacci
F[1]=1
F[2]=1
F[3]=2
F[4]=3
F[5]=5
F[6]=8
F[7]=13
F[8]=21
F[9]=34
F[10]=55
例5.3冒泡法排序(从小到大)
冒泡法排序对相邻的两个元素进行比较，并把小的元素交到前面。
public class BubbleSort{
public static void main(String args[]){
int i，j;
int intArray[]={30，1，-9，70，25};
int l=intArray.length;
for(i=0;i＜l-1;i++)
for(j=i+1;j＜l;j++)
if(intArray[i]＞intArray[j]){
int t=intArray[i];
intArray[i]=intArray[j];
intArray[j]=t;
}
for(i=0;i＜l;i++)
System.out.println(intArray[i]+"");
}
}
运行结果为：
C:\＞java BubbleSort
-9
1
25
30
70
§5.2多维数组
与C、C++一样，Java中多维数组被看作数组的数组。例如二维数组为一个特殊的一维数组，其每个元素又是一个一维数组。下面我们主要以二维数为例来进行说明，高维的情况是类似的。
一、二维数组的定义
二维数组的定义方式为：
type arrayName[][];
例如：
int intArray[][];
与一维数组一样，这时对数组元素也没有分配内存空间，同要使用运算符new来分配内存，然后才可以访问每个元素。
对高维数组来说，分配内存空间有下面几种方法：
1直接为每一维分配空间，如：
int a[][]=new int[2][3];
2从最高维开始，分别为每一维分配空间，如：
int a[][]=new int[2][];
a[0]=new int[3];
a[1]=new int[3];
完成1中相同的功能。这一点与C、C++是不同的，在C、C++中必须一次指明每一维的长度。
二、二维数组元素的引用
对二维数组中每个元素，引用方式为：arrayName[index1][index2] 其中index1、index2为下标，可为整型常数或表达式，如a[2][3]等，同样，每一维的下标都从0开始。
三、二维数组的初始化
有两种方式：
1直接对每个元素进行赋值。
2在定义数组的同时进行初始化。
如：int a[][]={{2，3}，{1，5}，{3，4}};
定义了一个3×2的数组，并对每个元素赋值。
四、二维数组举例：
例5.4矩阵相乘
两个矩阵Am×n、Bn×l相乘得到Cm×l，每个元素Cij=�aik*bk (i=1..m，n=1..n)
public class MatrixMultiply{
public static void main(String args[]){
int i，j，k;
int a[][]=new int[2][3];
int b[][]={{1，5，2，8}，{5，9，10，-3}，{2，7，-5，-18}};
int c[][]=new int[2][4];
for(i=0;i＜2;i++)
for(j=0;j＜3;j++)
a[i][j]=(i+1)*(j+2);
for(i=0;i＜2;i++){
for(j=0;j＜4;j++){
c[i][j]=0;
for(k=0;k＜3;k++)
c[i][j]+=a[i][k]*b[k][j];
}
}
System.out.println("\n***MatrixA***");
for(i=0;i＜2;i++){
for(j=0;j＜3;j++)
System.out.print(a[i][j]+"");
System.out.println();
}
System.out.println("\n***MatrixB***");
for(i=0;i＜3;i++){
for(j=0;j＜4;j++)
System.out.print(b[i][j]+"");
System.out.println();
}
System.out.println("\n***MatrixC***");
for(i=0;i＜2;i++){
for(j=0;j＜4;j++)
System.out.print(c[i][j]+"");
System.out.println();
}
}
}
其结果为：
C:\＞java MatrixMultiply
for(j=0;j＜4;j++)
System.out.print(c[i][j]+"");
System.out.println();
}
}
}
其结果为：
C:\＞java MatrixMultiply
***MatrixA***
2 3 4
4 6 8
***MatrixB***
1 5 2 8
5 9 10 -3
2 7 -5 -18
***MatrixC***
25 65 14 -65
50 130 28 -130
如果你学过线性代数，应该可以比较好地理解多维数组。
多维数组和矩阵结合紧密。
a[i][j]就是第i-1行的第j-1列的元素，因为下标是从0开始的。
比如：
一个数组：1 2 3
4 5 6
a[0][0]=1 a[0][1]=2 a[0][2]=3
a[1][0]=3 a[1][1]=5 a[1][2]=6
我推荐你看几本书：
1.Thinking in Java
2.Java 2 核心技术
3.Java2实用教程
4.面向对象程序设计与java语言