CRainyDay

Java基本语法续

Java数组

一.一维数组

数组: 相同数据类型的数据的组合.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
//如: 多个int
int score1 = 72;
int score2 = 90;
int score3 = 59;
//使用数组存储
int[] scores1 = new int[]{72,90,59};
//静态初始化:声明并初始化数组与给数组相应的元素赋值操作同时进行
int scores2[] = new int[3];//动态初始化:声明并初始化数组与数组相应的元素赋值操作分开进行
scores2[0] = 72;
scores2[1] = 90;
scores2[2] = 59;
int[] arr = {72,90,59};//这样可以
//声明数组的错误写法:
/*
String[] names = new String[5]{"AA","BB","CC"};//这样用时不能指定大小
int i[10];
int i = new int[];//i是int型
int[] arr;arr = {10,11,12};//两句分开不行, 合并为一句可以
*/
System.out.println(scores2.length);//求数组长度
for(int i = 0;i < scores1.length;i++){//遍历数组
System.out.println(scores1[i]);
}

注意

  1.不管是动态还是静态初始化数组, 一定在创建的时候, 就指明了数组的长度
  2.如何引用数组元素: 通过数组的下角标的方式. 下角标从0开始, 到n-1结束.其中n为数组的长度

  3.关于数组元素的默认初始化值

  • byte short int long 而言:0
  • float double 而言:0.0
  • char而言:空格
  • boolean而言:false
  • 引用类型变量而言:null

4.数组的内存结构

内存结构图:

内存结构图

在JAVA中, 凡是new出来的东西, 都会被默认初始化并赋值. new 出来的东西都存放在 堆中

对于数组来讲:

数组

字符串: 面向对象之后再看

String

二.二维数组

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
//1.声明并初始化
//一维:类型后一个[]
int[] i = new int[12];
i[0] = 12;
int[] j = new int[]{12,3};
//二维:类型后两个[]
String[][] str = new String[4][3];//4行3列
String[][] str1 = new String[4][];//4行, 每行的列可能不一样
str1[0] = new String[3];
//...
str1[3] = new String[5];
int[][] arr = new int[][]{{1,2,3},{4,5},{6}};
//2.如何引用二维数组的元素
arr[1][0] = 12;
//3.二维数组的长度:
arr.length;//3
arr[1].length;//2
//4.遍历二维数组
for(int i = 0;i < arr.length;i++){
for(int j = 0;j < arr[i].length;j++){
System.out.print(arr[i][j] + "\t");
}
System.out.println();
}

5.二维数组的结构:

String[][]

二维数组

三.数组中常见的异常

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
//1.数组下标越界的异常:java.lang.ArrayIndexOutOfBoundsException
int[] i = new int[10];
//i[0] = 90;
//i[10] = 99;//最大i[9]
//for(int m = 0;m <= i.length;m++){
// System.out.println(i[m]);//最大i[i.length-1]
//}

//2.空指针的异常:NullPointerException
//第一种:
//boolean[] b = new boolean[3];
//b = null;
//System.out.println(b[0]);//b已经为空

//第二种:
//String[] str = new String[4];
//System.out.println(str[3].toString());//没有初始化str[3]

//第三种:
int[][] j = new int[3][];
//j[2][0] = 12;//j的第二维还未初始化

四.数组中常用的算法

求数组元素的最大值&最小值&和&平均数

数组的复制和反转

情况1: 浅复制, 两个数组的引用指向同一片内存空间, 改变一个的内容另一个也会改变

1
2
int[] arr1 = new int[]{10,11,12};
int[] arr2 = arr1;

情况2: 深复制, 将一片内存里的内容, 复制到另一片内存里(如何实现复制)

1
2
3
4
5
int[] arr1 = new int[]{10,11,12};
int[] arr2 = new int[arr1.length];
for(int i = 0;i < arr1.length;i ++){
arr2[i] = arr1[i];
}

数组的反转:
数组元素的反转

1
2
3
4
5
6
7
8
9
10
11
12
//①
for(int i = 0;i < arr.length/2;i++){
int temp = arr[i];
arr[i] = arr[arr.length-1 - i];
arr[arr.length - 1 - i] = temp;
}
//②
for (int x = 0, y = arr.length - 1; x < y; x++, y--) {
int temp = arr[x];
arr[x] = arr[y];
arr[y] = temp;
}

拓展:String str = “abcdefg”;

数组的排序

  • 插入排序: 直接插入排序、折半插入排序、Shell排序
  • 交换排序: 冒泡排序、快速排序(或分区交换排序)

  • 选择排序: 简单选择排序、堆排序

  • 归并排序

  • 基数排序

使用冒泡排序使数组元素从小到大排列

1
2
3
4
5
6
7
8
9
for (int i = 0; i < arr.length - 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
13
14
for(int i = 0; i < arr.length - 1; i++){
int t = i;//默认i处是最小的
for(int j = i;j < arr.length;j++){
//一旦在i后发现存在比其小的元素,就记录那个元素的下角标
if(arr[t] > arr[j]){
t = j;
}
}
if(t != i){
int temp = arr[t];
arr[t] = arr[i];
arr[i] = temp;
}
}

还可以调用: Arrays工具类: Arrays.sort(arr);


 评论



本博客所有文章除特别声明外,均采用[(CC BY-NC-SA 4.0)]许可协议。转载请注明出处!

本站使用 Material X 作为主题 , 总访问量为 次 。
Copyright © 2019 CRainyDay's Blog 版权所有