JavaSE 基础 (3) 数组

1
2
3

//这里虽然是定义了一个数组，但也仅仅只是一个数组类型的[变量]，变量没有进行初始化，就直接使用了，这就是错误原因。
int[] arr;
System.out.println(arr);  //报错

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

public class Test{
	public static void main(String[] args){
		int[] s = null; //声明数组
		s = new int[10]; //给数组分配空间
		for (int i = 0;i < 10;i++){
			s[i] = 2 * i + 1; //给数组元素赋值
			System.out.println(s[i]);
		}
	}
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

class Man{
	private int age;
	private int id;

	public Man(int id,int age){
		super();
		this.age = age;
		this.id = id;
	}
}

public class AppMain{
	public static void main(String[] args){
		Man[] mans; //声明引用类型数组；
		mans = new Man[10]; //给引用类型数组分配空间：

		Man m1 = new Man(1,11);
		Man m2 = new Man(2,22);

		mans[0] = m1; //给引用类型数组元素赋值：
		mans[1] = m2; //给引用类型数组元素赋值：
	}
}

1
2
3
4
5
6
7
8

for(int i = 0;i < arr1.length;i++){
	arr1[i] = i * 2 + 1;
}

for(int i = 0;i < arr1.length;i++){
 	//数组长度是5，索引范围：[0,Length-1]
	System.out.println(arr1[i]);
}

1
2

int[] a = {1,2,3}; //静态初始化基本类型数组
Man[] mans = {new Man(1,1), new Man(2,2)}; //静态初始化引用类型数组;

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

public static void main(String[] args){
	//静态初始化需要在声明后直接初始化
	Man[] mans = {
			new Man(10, "高小一"),
			new Man(20, "高小二"),
			new Man(30, "高小三"),
			new Man(40, "高小四"),
			new Man(50, "高小五")
	};

	for(int i=0;i<mans.length;i++){
		System.out.println(mans[i].getName());
	}
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

public static void main(String[] args){
	Man m = new Man(10, "高小一");
	//静态初始化需要在声明后直接初始化
	Man[] mans ={
			m,
			new Man(20, "高小二"),
			new Man(30, "高小三"),
			new Man(40, "高小四"),
			new Man(50, "高小五")
			};
			
	mans[0] = m;
}

1
2
3
4
5
6
7
8

for(int i=0;i<mans.length;i++){
	System.out.println(mans[i].getName());
}

//增强for循环
for(Man man:mans){
	System.out.println(man);
}

1
2
3
4
5
6
7
8
9

for(int i=0;i<mans.length;i++){
	Man man = mans[i];
	System.out.println(man);
}

//增强for循环
for (Man man:mans){
	System.out.println(man);
}

1
2
3

int[] a1 = new int[2];  //动态初始化数组，先分配空间;
a1[0] = 1;  //给数组元素赋值;
a1[1] = 2;  //给数组元素赋值;

1
2
3
4
5

int[] arr = new int[5];
System.out.println(arr);   //[I@10f87f48

byte[] bArr new = byte[3];
System.out.println(bArr);   //[B@b4c966a

1
2
3

int a2[] = new int[2];  //默认值：0,0
boolean[] b = new boolean[2]; //默认值：false,false
String[] s = new String[2];  //默认值：null,null

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73

public class Score {
    private String name;
    private int fenShu;//分数

    public Score(String name,int fenShu){
        this.name = name;
        this.fenShu = fenShu;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getFenShu() {
        return fenShu;
    }

    public void setFenShu(int fenShu) {
        this.fenShu = fenShu;
    }
}

class Test{
    public static void main(String[] args) {
        /*
        静态初始化,需要在声明后，直接初始化
         */
        Score[] s = {new Score("java",60),
                     new Score("python",70),
                     new Score("大数据",80),
                     new Score("人工智能",90)};
        for(int i=0;i < s.length;i++){
            System.out.println(s[i].getName());
        }
        /*
        动态初始化
         */
        Score[] c = new Score[4];
        c[0] = new Score("java",60);
        c[1] = new Score("python",70);
        c[2] = new Score("大数据",80);
        c[3] = new Score("人工智能",90);
        for(int i=0;i < c.length;i++){
            System.out.println(s[i].getName() + "\t" + s[i].getFenShu());
        }
        /*
        默认初始化
         */
        Score[] score = new Score[4];
        for(int i=0;i < score.length;i++){
            System.out.println(score[i]);
        }
    }
}
运行结果
java
python
大数据
人工智能

java	60
python	70
大数据	80
人工智能	90

null
null
null
null

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

private static int binarySearchForIndex(int[]arr,int number){
	//1,定义查找的范围
	int min = 0;
	int max = arr.length -1;
	//2.循环查找 min<=max
	while(min <= max){
		//3.计算出中间位置mid
		int mid =(min + max) >> 1;
		//mid指向的元素 > number
		if(arr[mid] > number){
			//表示要查找的元素在左边，
			max = mid -1;
		}else if(arr[mid] < number){
			//mid指向的元素<number
			//表示要查找的元素在右边。
			min = mid +1;
		}else{
			//mid指向的元素==number
			return mid;
		}
	}
	//如果min大于了max就表示元素不存在，返回-1.
	return -1;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18

public static void main(String[] args){
	int[] arr = {3,5,2,1,4};
	//1 2 3 4 5

	//外层循环控制的是次数比数组的长度少一次
	for (int i=0; i<arr.length-1; i++){
		//内存循环就是实际循环比较的
		//-1:是为了让数组不要越界
		//-i:每一轮结束之后，我们就会少比一个数字。
		for(int j=0; j<arr.length-1-i; j++){
			if (arr[j] > arr[j +1]){
				int temp = arr[j];
				arr[j] = arr[j-1];
				arr[j-1] = temp;
			}
		}
	}
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

public class Test{
	public static void main(String[] args){
	int[] a = new int[4];
	//初始化数组元素的值
	for(int i=0;i<a.length;i++){
		a[0] = 100*i;
	}
	//读取元素的值
	for(int i=0;i<a.length;i++){
		System.out.println(a[i]);
	}
}

1
2
3
4
5
6
7
8

public class Test{
	public static void main(String[] args){
		String[] ss = {"aa","bbb","ccc","ddd");
		for(String temp : ss){
			System.out.println(temp);
		}
	}
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

public class Test{
	public static void main(String[] args){
		String[] s = ("阿里"，"京东"，"搜狐"，"网易");
		String[] sBak = new String[6];
		System.arraycopy(s, 0, sBak, 0, s.length);
		for (int i = 0;i < sBak.length; i++){
			System.outprint(sBak[i]+"\t");
		}
	}
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

public static void main(String[] args){
	int[] arr = {19, 28, 37, 46, 50};
	//1.定义两个变量，start和end来表示开始和结束的指针。
	//int start = 0;
	//int end = arr.length -1;
	//2.确定交换条件start<end允许交换
	for(int start = 0, int end = arr.length -1; start < end; start++, end--){
		//3.循环中编写交换逻辑代码
		int temp = arr[start];
		arr[start] = arr[end];
		arr[end] = temp;
	}
}

1
2
3

int[] arr = {1,2,3,4,5,6,7,8,9,10};
int index = Arrays.binarysearch(arr,10);
System.out.println(index);

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

import java.util.Arrays;

public class Test{
	public static void main(String[] args){
		int[] a = {1, 2, 323, 23, 543, 12, 59};
		System.out.println(Arrays.toString(a));
		Arrays.fill(a, 2, 4, 100);  //将2到4索引的元素替换为100:
		System.out.println(Arrays.toString(a));
	}
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

//二维数组的声明
public class Test{
	public static void main(String[] args){
		//Java中多维数组的声明和初始化应按从低维到高维的顺序进行
		int[][] a = new int[3][];
		a[0] = new int[2];
		a[1] = new int[4];
		a[2] = new int[3];
		//int a1[][] = new int[][4];//非法
	}
}

1
2
3
4
5
6
7
8

public static void main(String[] args){
	//Java中多维数组的声明和初始化应按从低维到高维的顺序进行
	int[][] a = new int[3][];
	a[0] = new int[2];
	a[1] = new int[4];
	a[2] = new int[3];
	//int a1[][] = new int[][4]是非法的
}

1
2
3
4
5
6
7
8

public static void main(String[] args){
	int[][] a = new int[3][];
	//a[0] = {1,2,5};  //错误，没有声明类型就初始化
	a[0] = new int[]{1,2};
	a[1] = new int[]{2,2};
	a[2] = new int[]{2,2,3,4};
	System.out.println(a[2][3]);
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

public static void main(String[] args){
	//数据类型[][] 变量名 = new 数据类型[m][n];
	int[][] arr = new int[3][3];
	/*
		[[I@10f87f48
		@:分隔符
		10f87f48：十六进制内存地址
		I:数组中存储的数据类型
		[[:几个中括号就代表的是几维数组
	*/
	System.out.println(arr);  //[[I@18f87f48
	
	/*
		二维数组存储一维数组的时候, 存储的是一维数组的内存地址
	*/
	System.out.println(arr[0]);  //[I@b4c966a
	System.out.println(arr[1]);  //[I@2f4d3709
	System.out.println(arr[2]);  //[I@4e50df2e
	
	System.out.println(arr[0][0]);  //0
	System.out.println(arr[1][1]);  //0
	System.out.println(arr[2][2]);  //0
	
	//向二维数组中存储元素
	arr[0][0] = 11;
	arr[0][1] = 22;
	arr[0][2] = 33;
	
	arr[1][0] = 11;
	arr[1][1] = 22;
	arr[1][2] = 33;
	
	arr[2][0] = 11;
	arr[2][1] = 22;
	arr[2][2] = 33;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

public static void main(String[] args)
	int[] arr1 = {11,22,33};
	int[] arr2 = {44,55,66};
	int[] arr3 = {77,88,99,100};  //<---看这里
	
	int[][] arr = new int[3][3];
	arr[0] = arr1;
	arr[1] = arr2;
	arr[2] = arr3;
	
	System.out.println(arr[1][2]);  //66
	System.out.println(arr[2][3]);  //100
}

提前创建好数组, 直接添加
------------------------------------
public static void main(String[] args)
	int[] arr1 = {11,22,33};
	int[] arr2 = {44,55,66};
	int[] arr3 = {77,88,99};
	
	int[][] arr = new int[3][3];
	
	arr[2][3] = 100;  //<---看这里

	arr[0] = arr1;
	arr[1] = arr2;
	arr[2] = arr3;
	
	System.out.println(arr[1][2]);
	System.out.println(arr[2][3]);  //ArrayIndexOutofBoundsException
}

1
2
3
4
5
6

public class Test {
	public static void main(String[] args){
		int[][] a = {{1,2,3},{3,4},{3,5,6,7}};
		System.out.println(a[2][3]);
	}
}

1
2
3
4
5
6

public static void main(String[] args){
	int[] arr1 = {11, 22, 33};
	int[] arr2 = {44, 55, 66};

	int[][] array = {arr1, arr2};
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

public class Test {
	public static void main(String[args){
		int[][] a = new int[3][];
		//a[0]=[1,2,5}//错误，没有声明类型就初始化
		a[0] = new int[]{1,2};
		a[1] = new int[]{2,2};
		a[2] = new int[]{2,2,3,4};
		System.out.println(a[2][3]);
		
		//获取的二维数组第一维数组的长度。
		System.out.println(a.length);
		//获取第二维第一个数组长度。
		System.out.println(a[0].length);
	}
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

public static void main(String[] args){
	int[][] arr ={{11, 22, 33}, {33, 44, 55}};
	//1.遍历二维数组，取出里面每一个一维数组
	for (int i = 0; i < arr.length; i++){
		//System.out.println(arr[i]);
		for (int j = 0; j < arr[i].length; j++)
			System.out.println(arr[i][j]);
		}
	}
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

public static void main(String[] args){
	//1.定义求和变量，准备记录最终累加结果
	int sum = 0;
	//2.使用二维数组来存储数据，每个季度是一个一维数组，再4个一维数组装起来
	int[][] arr = {{22, 66, 44},{77, 33, 88},{25, 45, 65},{11, 66, 99}};
	//3.遍历二维数组，获取所有元素，累加求和
	for(int i = 0; i < arr.length; i++){
		for(int j = 0; j < arr[i].length; j++){
			sum += arr[i][j];
		}
	}
}

1
2
3

Object[] a1 = {1001, "高小六", 18, "讲师", "2019-2-14"};
Object[] a2 = {1002, "高小七", 19, "助教", "2019-10-10"};
Object[] a3 = {1003, "高小八", 20, "班主任", "2019-5-5"};

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16

import java.util.Arrays;

public class Test {
	public static void main(String[] args) {
		Object[] a1 = {1001,"高小六",18,"讲师","2019-2-14"};
		Object[] a2 = {1002,"高小七",19,"助教","2019-10-10"};
		Object[] a3 = {1003,"高小八",20,"班主任","2019-5-5"};
		Object[][] emps = new Object[3][];
		emps[0] = a1;
		emps[1] = a2;
		emps[2] = a3;
		System.out.println(Arrays.toString(emps[0]));
		System.out.println(Arrays.toString(emps[1]));
		System.out.println(Arrays.toString(emps[2]));
	}
}

1
2
3

[1001,高小六,18,讲师,2019-2-14]
[1001,高小七,19,助教,2019-10-10]
[1001,高小八,20,班主任,2019-5-5]

1
2
3

for(int i = 0; i < emps.length; i++){
	System.out.println(Arrays.toString(emps[i]));
}

1
2
3
4
5
6
7

//使用嵌套循环打印二维数组（打印表格数据）
for(int i = 0; i < emps.length; i++){
	for(int j = 0; j < emps[i].length; j++){
		System.out.print(emps[i][j]+ "\t");
	}
		System.out.println();
}