JAVA入门之数组（一）
至此，java的基础语法已经基本总结完毕，接下来要学习的是数组。
1.数组（Array）的概述
- 数组，是多个相同类型数据按一定顺序排列的集合，并使用一个名字命名，并通过编号的方式对这些数据进行统一管理。
- 数组的常见概念：
1.数组名
2.元素
3.角标、下标、索引
4.数组的长度：元素的个数 - 数组的特点：
1.数组是有序排列的
2.数组属于引用数据类型的变量。数组的元素，既可以是基本数据类型，也可以是引用数据类型
3.创建数组对象会在内存中开辟一整块连续的空间
4.数组的长度一旦确定，就不能修改 - 数组的分类：
1.按照维数：一维数组、二维数组。。。。
2.按照数组元素的类型：基本数据类型元素的数组、引用数据类型元素的数组 - 一维数组的使用：
1.一维数组的声明和初始化
2.如何调用数组的指定位置的元素
3.如何获取数组的长度
4.如何遍历数组
5.数组元素的默认初始化值
6.数组的内存解析
public class AarryTest {
public static void main(String[] args) {
//1. 一维数组的声明和初始化
int num; //声明
num = 10; //初始化
int id = 100; //声明+初始化
int[] ids; //声明
//1.1静态初始化：数组的初始化和数组元素的赋值操作同时进行
ids = new int[]{1001,1002,1003,1004};
//1.2动态初始化：数组的初始化和数组元素的赋值操作分开进行
String[] names = new String[5];
//错误的写法
int[] arr1 = new int[];
int[5] arr2 = new int[5];
int[] arr3 = new int[3] {1,2,3};
//数组一旦初始化完成，其长度就确定了
}
}
public class AarryTest {
public static void main(String[] args) {
String[] names = new String[5];
//2. 如何调用数组的指定位置的元素：通过索引的方式调用
//数组的索引从0开始的，到数组的长度-1结束
names[0] = "王八";
names[1] = "王二";
names[2] = "王三";
names[3] = "王四";
names[4] = "王五";
//3. 如何获取数组的长度
//属性：length
System.out.println(names.length);//5
//4. 如何遍历数组
for(int i = 0; i < names.length; i++) {
System.out.println(names[i]);
}
}
}
数组元素的默认初始化值
- 数组元素是整型：0
- 数组元素是浮点型：0.0
- 数组元素是char型：0或’\u0000’，而非’0’
- 数组元素是boolean型：false
- 数组元素是引用数据类型：null (空值，没有赋值的意思)
public class AarryTest {
public static void main(String[] args) {
//5. 数组元素的默认初始化值
int[] arr = new int[4];
for(int i = 0;i < arr.length;i++) {
System.out.println(arr[i]);
}
System.out.println("***********");
short[] arr1 = new short[4];
for(int i = 0;i < arr1.length; i++) {
System.out.println(arr1[i]);
}
System.out.println("***********");
float[] arr2 = new float[5];
for(int i = 0;i < arr2.length; i++) {
System.out.println(arr2[i]);
}
System.out.println("***********");
char[] arr3 = new char[5];
for(int i = 0;i < arr3.length; i++) {
System.out.println("----"+arr3[i]+"****");
}
System.out.println("***********");
boolean[] arr4 = new boolean[5];
for(int i = 0;i < arr4.length; i++) {
System.out.println(arr4[i]);
}
System.out.println("***********");
String[] arr5 = new String[5];
System.out.println(arr5[0]);
}
}
- 内存结构的简单说明：
2.练习：一维数组的使用
1.从键盘读入学生成绩，找出最高分，并输出学生成绩等级。
成绩>=最高分-10 等级为“A”；
成绩>=最高分-20 等级为“B”；
成绩>=最高分-30 等级为“C”；
其余，等级为"D"。
import java.util.Scanner;
public class AarryTest {
public static void main(String[] args) {
//1.使用Scanner，读取学生个数
Scanner scanner = new Scanner(System.in);
System.out.println("请输入学生人数：");
int number = scanner.nextInt();
//2.创建数组，存储学生成绩，动态初始化
int[] scores = new int[number];
//3.给数组中的元素赋值
int maxScore = 0;
System.out.println("请输入"+number+"个学生成绩：");
for(int i = 0; i < scores.length; i++) {
scores[i] = scanner.nextInt();
//4.获取数组中的元素的最大值，即最高分
if(maxScore < scores[i]) {
maxScore = scores[i];
}
}
//5.根据每个学生成绩与最高分的差值，得到每个学生的等级，并输出等级和成绩
char level;
for(int i = 0; i < scores.length; i++) {
if(maxScore - scores[i] <= 10) {
level = 'A';
}else if(maxScore - scores[i] <= 20) {
level = 'B';
}else if(maxScore - scores[i] <= 30) {
level = 'C';
}else {
level = 'D';
}
System.out.println("student" + i + "score is" + scores[i] + ",grade is" + level);
}
}
}
3.多维数组的使用
3.1二维数组的使用
- 理解：
对于二维数组的理解，我们可以看成是一维数组array1又作为另一个一维数组array2的元素而存在 - 二维数组的使用：
1.二维数组的声明和初始化
2.如何调用数组的指定位置的元素
3.如何获取数组的长度
4.如何遍历数组
5.数组元素的默认初始化值
6.数组的内存解析
import java.util.Scanner;
public class AarryTest {
public static void main(String[] args) {
//1.二维数组的声明和初始化
//静态初始化
int[][] arr1 = new int[][] {{1,2,3},{4,5},{7,8,9}};
//动态初始化1
String[][] arr2 = new String[3][2];
//动态初始化2
String[][] arr3 = new String[3][];
//2.如何调用数组的指定位置的元素
System.out.println(arr1[0][1]); //2
System.out.println(arr2[1][1]); //null
arr3[1] = new String[4];
System.out.println(arr3[1][0]);//不是很能理解为啥输出是null
//3.如何获取数组的长度
System.out.println(arr1.length); //3
System.out.println(arr1[0].length); //3
System.out.println(arr1[1].length); //2
//4.如何遍历数组
for(int i = 0; i < arr1.length; i++) {
for(int j = 0; j < arr1[i].length; j++){
System.out.print(arr1[i][j] + " ");
}
System.out.println();
}
}
}
import java.util.Scanner;
public class AarryTest {
public static void main(String[] args) {
int[][] arr = new int[4][3];
System.out.println(arr[0]);//[I@1c4af82c
System.out.println(arr[0][0]);//0
System.out.println("**********");
float[][] arr1 = new float[4][3];
System.out.println(arr1[0]);//地址值[F@123a439b
System.out.println(arr1[0][0]);//0.0
System.out.println("**********");
String[][] arr2 = new String[4][2];
System.out.println(arr2[1]);//地址值[Ljava.lang.String;@53bd815b
System.out.println(arr2[1][1]);//null
System.out.println("**********");
double[][] arr3 = new double[4][];
System.out.println(arr3[1]);//null
System.out.println(arr3[1][0]);//报错
}
}
3.2二维数组的练习
1.使用二维数组打印一个10行的杨辉三角
提示：
第一行有1个元素，第n行有n个元素
每一行的第一个元素和最后一个元素都是1
从第三行开始，对于非第一个元素和最后一个元素的元素。即：
yanghui[i][j] = yanghui[i-1][j-1] + yanghui[i-1][j];
import java.util.Scanner;
public class AarryTest {
public static void main(String[] args) {
//1.声明并初始化二维数组
int [][] yanghui =new int[10][];//定义数组行数 .
//2.给数组的元素赋值
for(int i = 0; i < yanghui.length; i++) {
yanghui[i] = new int[i+1];//定义数组每行对应的列数，即第n行就有n列
//2.1给首末元素赋值
yanghui[i][0] = yanghui[i][i] = 1;
//2.2给每行非首末元素赋值
for(int j = 1; j < yanghui[i].length-1; j++) {
yanghui[i][j] = yanghui[i-1][j-1] + yanghui[i-1][j];
}
}
//3.遍历二维数组
for(int i = 0; i < yanghui.length; i++) {
for(int j = 0; j < yanghui[i].length; j++) {
System.out.print(yanghui[i][j] + " ");
}
System.out.println();
}
}
}
2.创建一个长度为6的int型数组，要求数组元素的值都在1-30之间，且是随机赋值。同时要求元素的值各不相同
import java.util.Scanner;
public class AarryTest {
public static void main(String[] args) {
//1.声明并初始化一维数组
int [] arr =new int[6];
//2.给数组的元素赋值:
//2.1利用for循环给数组赋值[1,30]内的随机数
for(int i = 0; i<arr.length; i++) {
arr[i] = (int)(Math.random()*30 + 1);
//2.2给首元素赋完值后，每个元素赋值后需要和其前面的每个元素进行比较看是否相等，如果一旦发现有相等就跳出比较循环，并给该元素重新赋值
for(int j = 0; j < i; j++) {
if(arr[i] == arr[j]) {
i--;//如果该元素与前面任意元素相等就跳出循环，i减1，这样i再加上1后就相当于还得重新给这个i赋值
· break;
}
}
}
//3.遍历一维数组
for(int i = 0; i < arr.length; i++) {
System.out.print(arr[i]+" ");
}
}
}
3.回形数
从键盘键入一个整数[1,20]。以该数字为矩阵的大小，把1，2，3，4…n*n的数字按照顺时针螺旋的形式填入其中。例如：输入数字2，则程序输出：1 2
***** ************************************************* ******************4 3
方法一：
import java.util.Scanner;
public class AarryTest {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
System.out.println("请输入一个1~20的整数：");
int n = scanner.nextInt();
//1.声明并初始化二维数组
int [][] arr =new int[n][n];
int s = n*n;
/*
k=1:向右 k=2:向下 k=3:向左 k=4:向上
*/
//2.给数组的元素赋值:
int k = 1;
int i = 0, j = 0;
for(int m = 1; m <= s; m++) {
if(k==1){
if(j < n && arr[i][j]==0){
arr[i][j++] = m;
}else {
k = 2;
i++;
j--;
m--;
}
}else if(k==2){
if(i < n && arr[i][j]==0){
arr[i++][j] = m;
}else {
k = 3;
i--;
j--;
m--;
}
}else if(k==3){
if(j>=0 && arr[i][j]==0){
arr[i][j--] = m;
}else {
k = 4;
i--;
j++;
m--;
}
}else if(k==4){
if(i>=0 && arr[i][j]==0){
arr[i--][j] = m;
}else {
k = 1;
i++;
j++;
m--;
}
}
}
//3.遍历二维数组
for(int x = 0; x < arr.length; x++) {
for(int y = 0; y < arr[x].length; y++) {
System.out.print(arr[x][y]+"\t");
}
System.out.println();
}
}
}
方法二：
import java.util.Scanner;
public class AarryTest {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
System.out.println("请输入一个1~20的整数：");
int n = scanner.nextInt();
int [][] arr = new int[n][n];
//1.声明并初始化二维数组
int count = 0;//要显示的数据
int maxX = n-1;//x轴最大下标
int maxY = n-1;//y轴最大下标
int minX = 0;//x轴最小下标
int minY = 0;//y轴最小下标
while(minX <= maxX){
for(int x = minX; x <= maxX; x++){
arr[minY][x] = ++count;
}
minY++;
for(int y = minY; y <= maxY; y++){
arr[y][maxX] = ++count;
}
maxX--;
for(int x = maxX; x >= minX; x--){
arr[maxY][x] = ++count;
}
maxY--;
for(int y = maxY; y >= minY; y--){
arr[y][minX] = ++count;
}
minX++;
}
//3.遍历二维数组
for(int x = 0; x < arr.length; x++) {
for(int y = 0; y < arr[x].length; y++) {
System.out.print(arr[x][y]+"\t");
}
System.out.println();
}
}
}
4.数组元素中的平均数等
定义一个int型的一维数组，包含10个元素，分别赋一些随机整数，然后求出所有元素的最大值、最小值、和值。要求：所有随机数都是两位数。
import javax.jws.soap.SOAPBinding;
import java.util.Scanner;
public class AarryTest {
public static void main(String[] args) {
int [] arr = new int[10];
for(int i = 0; i < arr.length; i++){
arr[i] = (int) (Math.random()*(99-10+1)+10);
}
//遍历
for(int i = 0; i < arr.length; i++){
System.out.print(arr[i] + "\t");
}
System.out.println();
//求数组元素的最大值
int maX = arr[0];
for(int i = 0; i < arr.length; i++){
if(arr[i] > maX){
maX = arr[i];
}
}
System.out.println("最大值为："+maX);
//求数组元素的最小值
int miN = arr[0];
for(int i = 0; i < arr.length; i++){
if(arr[i] < miN){
miN = arr[i];
}
}
System.out.println("最小值为："+miN);
//求数组元素的总和值
int sum = 0;
for(int i = 0; i < arr.length; i++){
sum += arr[i];
}
System.out.println("总和值为："+sum);
//求数组元素的平均值
int avge = 0;
avge = sum / arr.length;
System.out.println("平均值为："+avge);
}
}
5.数组的复制
使用简单数组
（1）创建一个名为ArrayTest的类，在main()方法中声明array1和array2两个变量，他们是int[]类型的数组。
（2）使用大括号{}，把array1初始化为8个素数：2，3，5，7，9，11，13，17，19。
（3）显示array1的内容。
（4）赋值array2变量等于array1，修改array2中的偶索引元素，使其等于索引值（如array[0]=0;array[2]=2）。打印出array1。
import javax.jws.soap.SOAPBinding;
import java.util.Scanner;
public class AarryTest {
public static void main(String[] args) {
int[] array1,array2;
array1 = new int[]{2,3,5,7,9,11,13,17,19};
//显示array1的内容
for(int i = 0;i < array1.length; i++){
System.out.print(array1[i]+"\t");
}
System.out.println();
//赋值array2变量等于array1
array2 = array1;//不能称做数组的复制
//数组的复制
array2 = new int[array1.length];
for(int i = 0;i < array2.length; i++){
array2[i] =array1[i];
}
//修改array2中的偶索引元素，使其等于索引值（如array[0]=0;array[2]=2）
for(int i = 0; i < array2.length; i++){
if(i%2 == 0){
array2[i] = i;
}
}
//打印array1的内容
for(int i = 0;i < array1.length; i++){
System.out.print(array1[i]+"\t");
}
}
}
上述例子说明：“array2 = array1；”这个操作只是把array1的地址给了array2并没有实现对array1的复制。即两个变量的地址值是一样的，但堆空间中只有一个数组，换言之，自始至终，只是new的一次。array2 和 array1地址值相同，都指向了堆空间中的唯一的一个数组实体。
数组的复制堆解释：
6.数组的反转与查找
import javax.jws.soap.SOAPBinding;
import java.util.Scanner;
public class AarryTest {
public static void main(String[] args) {
String[] arr = new String[]{"JJ","DD","MM","BB","GG","AA"};
//数组的复制（区别于数组变量的赋值：arr1 = arr）
String[] arr1 = new String[arr.length];
for(int i = 0; i < arr1.length; i++){
arr1[i] = arr[i];
}
//数组的反转
//方法一：
for(int i = 0; i < arr.length/2; i++){
String temp = arr[i];
arr[i] = arr[arr.length-1-i];
arr[arr.length-1-i] = temp;
}
//方法二：
for(int i=0,j=arr.length-1; i < j; i++,j--){
String temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}
//遍历
for(int i=0; i < arr.length; i++){
System.out.print(arr[i]+"\t");
}
System.out.println();
//查找（搜索）
//线性查找：
String dest = "CB";
boolean ifFlag =true;
for(int i = 0; i < arr.length;i++){
if(dest.equals(arr[i])){
System.out.println("找到了指定元素，位置为："+i);
ifFlag =false;
break;
}
}
if(ifFlag){
System.out.println("很遗憾没有找到！");
}
//二分法查找：前提，所要查找的数组必须是有序的
int[] arr2 = new int[]{-98,-34,2,34,54,66,79,105,210,333};
int dest1 = -34;
int head = 0;//初始的首索引
int end = arr2.length - 1;//初始的末索引
boolean ifFlag1 =true;
while(head <= end){
int middle = (head+end)/2;
if(dest1 == arr2[middle]){
System.out.println("找到了指定元素，位置为："+middle);
ifFlag1 =false;
break;
}else if(arr2[middle] > dest1){
end = middle-1;
}else{//arr2[middle] < dest1
head = middle + 1;
}
}
if(ifFlag1){
System.out.println("很遗憾没有找到！");
}
}
}
