Java基础/数组

数组：

创建数组

数组是一个固定长度的，包含了相同类型数据的 容器
声明数组：
int[] a;声明了一个数组变量。
[]表示该变量是一个数组
int 表示数组里的每一个元素都是一个整数
a 是变量名数组
里面都是整数。但是这一句声明，不会创建数组
创建数组：
创建数组时候，就需要指明数组长度。

int[] t = new int[5]//是对的
int t[] = new int[5];//是错的
Hero[] t; 和 Hero t[]; // 都是对的

引用概念：
如果变量代表一个数组，比如a,我们把a叫做引用
与基本类型不同int c = 5; 这叫给c赋值为5
声明一个引用 int[] a;

a = new int[5];

让a这个引用，指向数组
创建方法：

'先声明，再创建'
int[] a;//声明一个引用
a = new int[5];//创建一个长度是5的数组，并且使用引用a指向该数组
'声明的同时，指向一个数组'         
int[] b = new int[5]; //声明的同时，指向一个数组

访问数组：a[0]
.length属性用于访问一个数组的长度a.length
找最小值：

public class Shuzu {
    public static void main(String[] args) {
        int[] a=new int[5]; //创建长度为5的数组
        a[0]=(int)(Math.random()*100); //随机整数赋值
        a[1]=(int)(Math.random()*100);
        a[2]=(int)(Math.random()*100);
        a[3]=(int)(Math.random()*100);
        a[4]=(int)(Math.random()*100);
        int c=a[0];//用来比较
        int b = 0;//用来计
        System.out.println("数据中的各个随机数是:");
        for(int i=0;i<a.length;i++) {
            b=a[i];
            System.out.println(b); 
            /*进度比较*/
            if(c>b) {
                c=b;
            }
        }
        System.out.println("本练习的目的是，找出最小的一个值:"+c);
    }
}

数组赋值

1 .单个赋值：

        int[] a = new int[5]; //分配了长度是5的数组，但是没有赋值，没有赋值，那么就会使用默认值
        //作为int类型的数组，默认值是0         
        //进行赋值
        a[0] = 100;
        a[1] = 101;

2.分配空间同时赋值：

//写法一：
int[] a = new int[]{100,200,300}
//写法二：
int[] b = {100,102,444,836,3236};
//写法三 同时分配空间，和指定内容

//长度是3，内容是5个，产生矛盾了，所以如果指定了数组的内容，就不能同时设置数组的长度
int[] b = new int[3]{100,102,444,836,3236};

当定义的int t[] = null,再去访问数组里面值的时候，会出现空指针异常。

数组排序：

1 选择法（相当于依次向后寻找最小值)
选择法排序的思路：
把第一位和其他所有的进行比较，只要比第一位小的，就换到第一个位置来，依次类推
2 冒泡排序（两个两个比较）

'排序：'
package jincheng;

import java.util.Arrays;
public class test {
	public static void main(String[] args){
		int[] t = new int[]{1,6,45,78,19,16,48,78,25};
		//int[] u = new int[t.length];
		int temp = 0;
		int count = 0;	
		for(int i =0;i<t.length-1;i++){
			for (int j=0;j<t.length-i-1;j++){
				if (t[j]>t[j+1]){
					temp = t[j];
					t[j] = t[j+1];
					t[j+1] = temp;
					++count;
				}
			}
		}
		System.out.println(Arrays.toString(t));
		System.out.println(count);
	}
}

增强型数组for(int each : 数组名){…}

package j2se;

public class lian {
    public static void main(String[] args) {
    	int values [] = new int[]{18,62,68,82,65,9};   	         
    	 //增强型for循环遍历
    	for (int each : values) {
    		System.out.println(each);
    	}
//找出最大值
    	int max=0;
    	for(int each: values) {
    		if(each>max) {
    			max=each;
    			}
    		}
    	System.out.println("\n此数组中最大值是：\n"+max);
    	}
    }

复制数组

把一个数组的值，复制到另一个数组中：

System.arraycopy(src, srcPos, dest, destPos, length)

src: 源数组
srcPos: 从源数组复制数据的起始位置
dest: 目标数组
destPos: 复制到目标数组的起始位置
length: 复制的长度
合并数组：

package j2se;

public class lian {
    public static void main(String[] args) {
    	int values [] = new int[]{18,62,68,82,65,9};
    	int[] a = new int[]{10,20,30,60};
    	int[] c = new int[values.length + a.length];
    	System.arraycopy(values, 0, c, 0, values.length);
    	System.arraycopy(a, 0, c, values.length, a.length);
    	for (int each: c){
    		System.out.print(each +" ");
    	}
    	}
    }

二维数组

int b[][] = new int[][]{
   {1,2,3},
   {4,5,6},
   {7,8,9}
};
int[][] t = new int[i][j];
第一维数组长度：t.length
第二维数组数组：t[i].length

public class HelloWorld {
    public static void main(String[] args) {
       //初始化二维数组，
       int[][] a = new int[2][3]; //有两个一维数组，每个一维数组的长度是3
       a[1][2] = 5;  //可以直接访问一维数组，因为已经分配了空间
          
       //只分配了二维数组
       int[][] b = new int[2][]; //有两个一维数组，每个一维数组的长度暂未分配
       b[0]  =new int[3]; //必须事先分配长度，才可以访问
       b[0][2] = 5;
        
       //指定内容的同时，分配空间
       int[][] c = new int[][]{
               {1,2,4},
               {4,5},
               {6,7,8,9}
       };
 		int[] x,y[];x是一维数组，y是二维数组
    }
}

求随机数组的和：

package jincheng;
public class test {
	public static void main(String[] args){
		int[][] t = new int[4][5];
		int y = 0;
		for (int i = 0;i<t.length;i++){
			for(int j=0;j<t[i].length;j++){
				t[i][j]=(int)(Math.random()*100+1);
				System.out.print(t[i][j]+" ");
				y = y+t[i][j];
			}
			System.out.print("\n");
		}
		System.out.println(y);
	}
}

创建二维数组，并找最大值，然后返回坐标：

package j2se;

public class lian {
    public static void main(String[] args) {
    	int a[][]=new int[5][5];
        for(int i=0;i<5;i++) {
            for (int j = 0; j < 5; j++) {
                a[i][j]=(int)(Math.random()*100);  
                System.out.print(a[i][j]+"\t");
            }
            System.out.println();
        }
        int maxn=a[0][0];
        int x=0;
        int y=0;
        for(int i=0;i<5;i++) {
            for (int j = 0; j < 5; j++) {
                    if(a[i][j]>maxn) {  
                        maxn=a[i][j];
                        x=i;
                        y=j;
                    }                      
            }
        }      
        System.out.println("找出来最大的是："+maxn);
        System.out.println("其坐标是："+"["+x+"]"+"["+y+"]");
    	}
    }

Arrays 数组工具类

数组复制：
copyOfRange进行数组复制
与System.arraycopy的不同：
System.arraycopy需要事先准备好目标数组，并分配长度
copyOfRange:只需要源数组就就可以了，通过返回值，就能够得到目标数组了。
需要注意的是 copyOfRange 的第3个参数，表示源数组的结束位置，是取不到的。
// copyOfRange(int[] original, int from, int to)
// 第一个参数表示源数组
// 第二个参数表示开始位置(取得到)
// 第三个参数表示结束位置(取不到)

import java.util.Arrays;
 
public class HelloWorld {
    public static void main(String[] args) {
        int a[] = new int[] { 18, 62, 68, 82, 65, 9 };
        int[] b = Arrays.copyOfRange(a, 0, 3){ 
        for (int i = 0; i < b.length; i++) {
            System.out.print(b[i] + " ");
        }
    }
}

转换为字符串:
如果要打印一个数组的内容，就需要通过for循环来挨个遍历，逐一打印
但是Arrays提供了一个toString()方法，直接把一个数组，转换为字符串，这样方便观察数组的内容

package j2se;

import java.util.Arrays;

public class lian {
    public static void main(String[] args) {
    	int values [] = new int[]{18,62,68,82,65,9};
    	String c = Arrays.toString(values);
    	System.out.println(c);
    	}
    }

排序:
Arrays工具类提供了一个sort方法,对数组进行排序。

		Arrays.sort(values);
    	System.out.println(Arrays.toString(values));

搜索：
需要注意的是，使用binarySearch进行查找之前，必须使用sort进行排序
如果数组中有多个相同的元素，查找结果是不确定的
判断是否相同：

        int a[] = new int[] { 18, 62, 68, 82, 65, 9 };
        int b[] = new int[] { 18, 62, 68, 82, 65, 8 };
        System.out.println(Arrays.equals(a, b));

填充：

		int a[] = new int[10];
        Arrays.fill(a, 5);