Java数组、排序、查找

目录

数组的基本概念及作用

数组的声明的两种方式：

数组创建的三种方式：

数组的访问与迭代（遍历）

数组赋值机制

数组拷贝

数组反转

数组添加/扩容

排序

查找

多维数组-二维数组

---

数组的基本概念及作用

• Java中 数组是相同数据类型元素的集合

• 数组本身是引用数据类型，即对象。（下章面向对象讲）但是数组可以存储基本数据类型， 也可以存储引用数据类型。

数组的声明的两种方式：

• 数据类型 [] 数组名字 例如：int [] a; 

• 数据类型 数组的名字 [] 例如： int a [];

• 注意： 在Java语言中两种声明方法没有任何区别，但是建议大家用第一种， 避免混淆a的数据类型

例 // int [] c,d;(建议的)

// int c[],d;(不建议) 容易混淆有歧义，误以为int c[]数组 ，int d 变量

数组创建的三种方式：

● 声明数组的同时，根据指定的长度分配内存，但数组中元素值都为数组类型默认的初始化值

例：int类型 0 ； float类型 0.0 ； string类型 null；......

创建数组时必须明确数组的容量,容量一旦确定,不能改变

//动态创建数组 （没有为元素赋值，可以结合for循环进行赋值）

int[] ary0 = new int[10]; // 创建了一个容量为10的int型数组

● 声明数组并分配内存，同时将其初始化

//静态创建数组，创建数组时,为数组赋值,容量就由值的个数决定

int[] ary1 = new int[]{1, 2, 3, 4, 5};

● 与前一种方式相同，仅仅只是语法相对简略

int[] ary2 = {1, 2, 3, 4, 5};

 System.out.println(Arrays.toString(ary0));  
//  Java通过Arrays.toString(a)这个方法，把数组以字符串的形式输出 便于调试,
//  若不加则数组会被当作对象，输出的是在内存中存储的地址[I@4554617c
 加了后实际结果为 [0,0,0,0,0,0,0,0,0,0]

例如

public static void main(String[] args) {     
int[] a = new int[5];   //创建了一个容量为5的数组   
                        //若不用Arrays.toString此时输出的是数组的地址[I@1d6b3586
int b[] = new int[10];   //创建了一个容量为10的数组
    
System.out.println(Arrays.toString(a)); //Arrays.toString(a)把数组以字符串的形式输出 便于调试    

System.out.println(Arrays.toString(b)); 
//创建数组时,为数组赋值,容量就由值的个数决定    
int[] c = new int[]{1,2,3,4,5,6,7};   // Arrays.toString 使用时自动会匹配对应类型的方法 
      // int[] c = {1,2,3,4,5,6,7};  //Java中若明确数组的值，那也可以直接这样写
         System.out.println(Arrays.toString(c));   
        char [] chars = new char[5];   
            System.out.println(Arrays.toString(chars));   
}
结果：[0，0，0，0，0]
     [0,0,0,0,0,0,0,0,0,0]
     [1,2,3,4,5,6,7]
     [ , , , , ]
     

数组的访问与迭代（遍历）

数组元素的访问： 数组里面可以存储多个值,如何访问(赋值,获取)数组中的每个值

数组中每个空间,都有一个下标( 索引 index 编号)

• 数组名字[索引]  例如：a[0],a[1];

数组中每个空间,都有一个下标(索引 index 、编号、)

• 索引的特点：• 数组的索引从0开始。

• 索引的数据类型是整数

• 索引最大值和数组长度始终差1 即 最大索引  为  (数组长度-1) 若超出则为数组索引越界

//数组内部的空间都必须是连续的 

   例如              [1,2,3,4,5]        

   则他的索引是        0 1 2 3 4   

例如  int [] a = new int[5];    

​               a[0] = 2;     

​               a[1] = 5;     

​               a[2] = 4;     

​               a[3] = 8;     

​               a[4] = 10;    

​          // a[5] = 10;       //数组索引越界

也不能是a[-1]=10;    //索引以0开始

System.out.println(Arrays.toString(a));        

/*  报错  出现了异常 Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException:
 5 at day1.Demo2.main(Demo2.java:24)  */

//System.out.println(a[2]);    结果是4

数组遍历 ： 取出数组中每一个值 // index 0 -- ->长度-1

可通过 数组名+索引号 访问数组中的某个位置

例如：

public static void main(String[] args) {

​             int [] a = new int[5];    

​                 a[0] = 2;    

​                 a[1] = 5;    

​                 a[2] = 4;   

​                 a[3] = 8;    

​                 a[4] = 10;   // index (索引) 从0开始  ---->到 长度-1 

​    如何知道一个数组长度是多少？

​             System.out.println(a.length);  结果是5，所以长度为5

​    如何去除数组每一个值？（数组遍历）  利用for循环，结合数组特征

 for(int i=0;i<a.length;i++){  

​         System.out.println(a[i]);   结果：2 5 4 8 10

​    }

}

数组迭代（遍历）的两种方式：

第一种：for循环 特点：每次从数组中取出一个元素，用到了索引，遍历可以任意从某个值开始，截止到某一个值就停止

例 int [] b1 = new int []{1,2,3,4,5,6,7};

数组的迭代 （遍历）

for(int i =0;i<b1.length;i++){

System.out.println(b1[i]);

}

结果 1 2 3 4 5 6 7

      普通 for循环 --->遍历可以任意从某个值开始，截止到某一个值就停止

例如 例 int [] b1 = new int []{1,2,3,4,5,6,7};

数组的迭代 （遍历）

for(int i =2;i < b1.length-1 ; i++){

System.out.println(b1[i]);

}

结果 3 4 5 6

第二种：增强for循环 （简化了for循环语句） 特点（隐藏遍历的细节 每次从数组中取出一个元素    但只能一次性遍历完每个值，不能随意从某个值开始或截止）

int [] b1 = new int []{1,2,3,4,5,6,7};

for(数组元素的类型 临时变量名字 ：数组的名字){

System.out.println(临时变量名字 );

}

即：

for(int x:b1){

System.out.println(x);

}

结果仍然是 1 2 3 4 5 6 7

数组使用注意事项和细节

1) 数组是多个相同类型数据的组合，实现对这些数据的统一管理

2) 数组中的元素可以是任何数据类型，包括基本类型和引用类型，但是不能混用。

3) 数组创建后，如果没有赋值，有默认值

int 0，short 0, byte 0, long 0, float 0.0,double 0.0，char \u0000，boolean false，String null

4) 使用数组的步骤 1. 声明数组并开辟空间 2 给数组各个元素赋值 3 使用数组

5) 数组的下标是从 0 开始的。

6) 数组下标必须在指定范围内使用，否则报：下标越界异常，比如

int [] arr=new int[5]; 则有效下标为 0-4

7) 数组属引用类型，数组型数据是对象(object)

数组赋值机制

1) 基本数据类型赋值，这个值就是具体的数据，而且相互不影响。

int n1 = 2; int n2 = n1;

2) 数组在默认情况下是引用传递，赋的值是地址。

看一个案例，并分析数组赋值的内存图(重点, 难点. )。

int[] arr1 = {1,2,3};

int[] arr2 = arr1;

数组拷贝

编写代码 实现数组拷贝(内容复制) ArrayCopy.java

将 int[] arr1 = {10,20,30}; 拷贝到 arr2 数组, 要求数据空间是独立的.

public static void main(String[] args) {
	//将 int[] arr1 = {10,20,30}; 拷贝到 arr2 数组, 
//要求数据空间是独立的. int[] arr1 = {10,20,30};
	//创建一个新的数组 arr2,开辟新的数据空间
	//大小 arr1.length;
	int[] arr2 = new int[arr1.length];
	//遍历 arr1 ，把每个元素拷贝到 arr2 对应的元素位置
	for(int i = 0; i < arr1.length; i++) {
		arr2[i] = arr1[i];
	}
	//修改 arr2， 不会对 arr1 有影响. arr2[0] = 100;
	//输出 arr1
	System.out.println("====arr1 的元素====");
	for(int i = 0; i < arr1.length; i++) {
		System.out.println(arr1[i]);//10,20,30
	}
	//
	System.out.println("====arr2 的元素====");
	for(int i = 0; i < arr2.length; i++) {
		System.out.println(arr2[i]);//
	}
}

数组反转

要求：把数组的元素内容反转。 ArrayReverse.java

arr {11,22,33,44,55,66}

{66, 55,44,33,22,11}

方式 1：通过找规律反转 【思路分析】

//编写一个 main 方法 

public static void main(String[] args) { 

	//定义数组 
	int[] arr = {11, 22, 33, 44, 55, 66}; 
//思路 
//规律 
//1. 把 arr[0] 和 arr[5] 进行交换 {66,22,33,44,55,11}
//2. 把 arr[1] 和 arr[4] 进行交换 {66,55,33,44,22,11} 
//3. 把 arr[2] 和 arr[3] 进行交换 {66,55,44,33,22,11} 
//4. 一共要交换 3 次 = arr.length / 2 
//5. 每次交换时，对应的下标 是 arr[i] 和 arr[arr.length - 1 -i] 
//代码 
//优化 
    int temp = 0; 
    int len = arr.length; //计算数组的长度 
    for( int i = 0; i < len / 2; i++) { 
		temp = arr[len - 1 - i];//保存 
		arr[len - 1 - i] = arr[i]; 
		arr[i] = temp; 
	} 
    System.out.println("===翻转后数组==="); 
    for(int i = 0; i < arr.length; i++) { 
	System.out.print(arr[i] + "\t");//66,55,44,33,22,11 
	} 
}

方式 2：使用逆序赋值方式

//编写一个 main 方法
public static void main(String[] args) {
//定义数组
	int[] arr = {11, 22, 33, 44, 55, 66};
//使用逆序赋值方式
//思路
//1. 先创建一个新的数组 arr2 ,大小 arr.length
//2. 逆序遍历 arr ,将 每个元素拷贝到 arr2 的元素中(顺序拷贝)
//3. 建议增加一个循环变量 j -> 0 -> 5
	int[] arr2 = new int[arr.length];
//逆序遍历 arr
	for(int i = arr.length - 1, j = 0; i >= 0; i--, j++) {
	arr2[j] = arr[i];
	}
//4. 当 for 循环结束，arr2 就是一个逆序的数组 {66, 55, 44,33, 22, 11}
//5. 让 arr 指向 arr2 数据空间, 此时 arr 原来的数据空间就没有变量引用
// 会被当做垃圾，销毁
			arr = arr2;
	System.out.println("====arr 的元素情况=====");
//6. 输出 arr 看看
			for(int i = 0; i < arr.length; i++) {
		System.out.print(arr[i] + "\t");
	}
}

数组添加/扩容

要求：实现动态的给数组添加元素效果，实现对数组扩容。ArrayAdd.java

1) 原始数组使用静态分配 int[] arr = {1,2,3}

2) 增加的元素 4，直接放在数组的最后 arr = {1,2,3,4}

3) 用户可以通过如下方法来决定是否继续添加，添加成功，是否继续？y/n

代码

import java.util.Scanner;
//编写一个 main 方法
public static void main(String[] args) {
/*
要求：实现动态的给数组添加元素效果，实现对数组扩容。ArrayAdd.java
1.原始数组使用静态分配 int[] arr = {1,2,3}
2.增加的元素 4，直接放在数组的最后 arr = {1,2,3,4}
3.用户可以通过如下方法来决定是否继续添加，添加成功，是否继续？y/n
思路分析
1. 定义初始数组 int[] arr = {1,2,3}//下标 0-2
2. 定义一个新的数组 int[] arrNew = new int[arr.length+1];
3. 遍历 arr 数组，依次将 arr 的元素拷贝到 arrNew 数组
4. 将 4 赋给 arrNew[arrNew.length - 1] = 4;把 4 赋给 arrNew 最后一个元素
5. 让 arr 指向 arrNew ; arr = arrNew; 那么 原来 arr 数组就被销毁
6. 创建一个 Scanner 可以接受用户输入
7. 因为用户什么时候退出，不确定，老师使用 do-while + break 来控制
*/
	Scanner myScanner = new Scanner(System.in);
//初始化数组
	int[] arr = {1,2,3};
	do {
	int[] arrNew = new int[arr.length + 1];
//遍历 arr 数组，依次将 arr 的元素拷贝到 arrNew 数组
	for(int i = 0; i < arr.length; i++) {
		arrNew[i] = arr[i];
	}
	System.out.println("请输入你要添加的元素");
	int addNum = myScanner.nextInt();
//把 addNum 赋给 arrNew 最后一个元素
	arrNew[arrNew.length - 1] = addNum;
//让 arr 指向 arrNew, arr = arrNew;
//输出 arr 看看效果
	System.out.println("====arr 扩容后元素情况====");
	for(int i = 0; i < arr.length; i++) {
	System.out.print(arr[i] + "\t");
}
//问用户是否继续
	System.out.println("是否继续添加 y/n");
	char key = myScanner.next().charAt(0);
	if( key == 'n') { //如果输入 n ,就结束
	break;
	}
	}while(true);
		System.out.println("你退出了添加...");
	}
}

排序

排序是将多个数据，依指定的顺序进行排列的过程。

排序的分类：

内部排序:

指将需要处理的所有数据都加载到内部存储器中进行排序。包括(交换式排序法、选择式排序法和插入式排序法)

外部排序法：

数据量过大，无法全部加载到内存中，需要借助外部存储进行排序。包括(合并排序法和直接合并排序法)。

冒泡排序

思想：每次取出相邻的两个元素进行比较,把较大的向后移动,小的向前移动

例如： {5,4,3,2,1};

4,3,2,1,5

3,2,1,4,5

2,1,3,4,5

1,2,3,4,5

public static void main(Strings args){
      int[] a = {5,4,3,2,1};
      for(int i = 0;i < a.length-1;i++){//比较的趟数
          for(int j = 0;j<a.length-1-i;j++){
          if(a[j]>a[j+1]){//比较
          int temp = a[j];//先寄存一个大的
          a[j] = a[j+1];
          a[j+1] = temp;//交换
          }
        }
     }
    System.out.println(Arrays.toString(a));
}

结果：[1, 2, 3, 4, 5]

     数据结构演示参考网站

https://www.cs.usfca.edu/~galles/visualization/Algorithms.html

https://visualgo.net/en

选择排序

从第一个元素开始，与后面的每一个元素进行比较，把较小的元素与当前元素进行交换

选择排序：从 待排序序列 中，按指定规则选出某一元素，再依照规定交换位置后达到排序目的。从 待排序序列 中找出 最小值，与下标 0 位置元素 交换。之后在剩余元素中找出 最小值，与下标 1 元素 交换。以此类推，直到完成。

例如
public static void main(String[] args) {       
    
               int[] a = {5,1,4,3,2};    
                 for(int i=0;i<a.length-1;i++){            
                   for(int j=i+1;j<a.length;j++){       
                    if(a[i]>a[j]){           
                        int temp = a[i];
                        a[i] = a[j+1];
                         a[j] = temp;
            }      
        }          
    } 
             System.out.println(Arrays.toString(a));
}

优化后：
public static void main(String[] args) {       
   
               int[] a = {5,1,4,0,2};    
                 for(int i=0;i<a.length-1;i++){        
                  int minIndex = i;//i=0 假设第一个就是最小的      
                   for(int j=i+1;j<a.length;j++){       
                    if(a[minIndex]>a[j]){           
                minIndex = j; //minindex记录最小值所在的位置      
          }      
     }          
               int temp = a[minIndex];  //内层循环体外；一趟比较完成后,只交换一次即可        
                a[minIndex] = a[i];         
               a[i] = temp;   
      }  
             System.out.println(Arrays.toString(a));
}

查找

介绍： 在 java 中，我们常用的查找有两种:

1) 顺序查找 SeqSearch.java

2) 二分查找【二分法，我们放在算法讲解】

6.12.2 案例演示：

1) 有一个数列：白眉鹰王、金毛狮王、紫衫龙王、青翼蝠王猜数游戏：从键盘中任意输入一个名称，判断数列中是否

包含此名称【顺序查找】 要求: 如果找到了，就提示找到，并给出下标值

import java.util.Scanner;
public class SeqSearch {
//编写一个 main 方法
public static void main(String[] args) {
/*
有一个数列：白眉鹰王、金毛狮王、紫衫龙王、青翼蝠王猜数游戏：
从键盘中任意输入一个名称，判断数列中是否包含此名称【顺序查找】
要求: 如果找到了，就提示找到，并给出下标值
思路分析
1. 定义一个字符串数组
2. 接收用户输入, 遍历数组，逐一比较，如果有，则提示信息，并退出
*/
//定义一个字符串数组
	String[] names = {"白眉鹰王", "金毛狮王", "紫衫龙王", "青翼蝠王"};
Scanner myScanner = new Scanner(System.in);
	System.out.println("请输入名字");
String findName = myScanner.next();
//遍历数组，逐一比较，如果有，则提示信息，并退出
//给大家一个编程思想/技巧, 一个经典的方法
	int index = -1;
	for(int i = 0; i < names.length; i++) {
//比较 字符串比较 equals, 如果要找到名字就是当前元素
	if(findName.equals(names[i])) {
	System.out.println("恭喜你找到 " + findName);
	System.out.println("下标为= " + i);
//把 i 保存到 index
		index = i;
		break;//退出
	}
}
		if(index == -1) { //没有找到
	System.out.println("sorry ,没有找到 " + findName);
		}
	}
}

多维数组-二维数组

多维数组我们只介绍二维数组。

二维数组的应用场景

比如我们开发一个五子棋游戏，棋盘就是需要二维数组来表示。

快速入门案例：

public class TwoDimensionalArray01 {
//编写一个 main 方法
public static void main(String[] args) {
/*
请用二维数组输出如下图形
0 0 0 0 0 0
0 0 1 0 0 0
0 2 0 3 0 0
0 0 0 0 0 0
*/
//什么是二维数组：
//老韩解读
//1. 从定义形式上看 int[][]
//2. 可以这样理解，原来的一维数组的每个元素是一维数组, 就构成二维数组
int[][] arr = { {0, 0, 0, 0, 0, 0}, {0, 0, 1, 0, 0, 0}, 
               {0,2, 0, 3, 0, 0}, {0, 0, 0, 0, 0, 0} };
//关于二维数组的关键概念
//(1)System.out.println("二维数组的元素个数=" + arr.length);
//(2) 二维数组的每个元素是一维数组, 所以如果需要得到每个一维数组的值
// 还需要再次遍历
//(3) 如果我们要访问第 (i+1)个一维数组的第 j+1 个值 arr[i][j];
// 举例 访问 3, =》 他是第 3 个一维数组的第 4 个值 arr[2][3]
System.out.println("第 3 个一维数组的第 4 个值=" + arr[2][3]); //3
//输出二维图形
for(int i = 0; i < arr.length; i++) {//遍历二维数组的每个元素
//遍历二维数组的每个元素(数组)
//老韩解读
//1. arr[i] 表示 二维数组的第 i+1 个元素 比如 arr[0]：二维数组的第一个元素
//2. arr[i].length 得到 对应的 每个一维数组的长度
	for(int j = 0; j < arr[i].length; j++) {
	System.out.print(arr[i][j] + " "); //输出了一维数组
	}
	System.out.println();//换行
	}
	}
}

使用方式 1: 动态初始化

1) 语法: 类型 数组名=new 类型大小

2) 比如: int a=new int2

3) 使用演示

4) 二维数组在内存的存在形式(!!画图)

 代码

public class TwoDimensionalArray02 {
//编写一个 main 方法
public static void main(String[] args) {
//int arr[][] = new int[2][3];
    int arr[][]; //声明二维数组
    arr = new int[2][3];//再开空间
    arr[1][1] = 8;
//遍历 arr 数组
    for(int i = 0; i < arr.length; i++) {
    for(int j = 0; j < arr[i].length; j++) {//对每个一维数组遍历
    System.out.print(arr[i][j] +" ");
    }
	System.out.println();//换行
	}
	}
}

使用方式 2: 动态初始化

先声明：类型 数组名; TwoDimensionalArray02.java

再定义(开辟空间) 数组名 = new 类型大小

赋值(有默认值，比如 int 类型的就是 0)

使用演示

使用方式 3: 动态初始化-列数不确定

public class TwoDimensionalArray03 {
//编写一个 main 方法
public static void main(String[] args) {
/*
看一个需求：动态创建下面二维数组，并输出
i = 0: 1
i = 1: 2 2
i = 2: 3 3 3 一个有三个一维数组, 每个一维数组的元素是不一样的
*/
//创建 二维数组，一个有 3 个一维数组，但是每个一维数组还没有开数据空间
    int[][] arr = new int[3][];
    for(int i = 0; i < arr.length; i++) {//遍历 arr 每个一维数组
//给每个一维数组开空间 new
//如果没有给一维数组 new ,那么 arr[i]就是 null
    arr[i] = new int[i + 1];
//遍历一维数组，并给一维数组的每个元素赋值
	for(int j = 0; j < arr[i].length; j++) {
	arr[i][j] = i + 1;//赋值
}
}
	System.out.println("=====arr 元素=====");
//遍历 arr 输出
	for(int i = 0; i < arr.length; i++) {
//输出 arr 的每个一维数组
	for(int j = 0; j < arr[i].length; j++) {
	System.out.print(arr[i][j] + " ");
	}
	System.out.println();//换行
	}
	}
}

使用方式 4: 静态初始化

定义 类型 数组名 = {{值 1,值 2..},{值 1,值 2..},{值 1,值 2..}}

使用即可 [ 固定方式访问 ]

比如:

int arr = {{1,1,1}, {8,8,9}, {100}};

解读

\1. 定义了一个二维数组 arr

\2. arr 有三个元素(每个元素都是一维数组)

\3. 第一个一维数组有 3 个元素 , 第二个一维数组有 3 个元素, 第三个一维数组有 1 个元素

案例 ：int arr={{4,6},{1,4,5,7},{-2}}; 遍历该二维数组，并得到和

public class TwoDimensionalArray05 {
//编写一个 main 方法
	public static void main(String[] args) {
/*
	int arr[][]={{4,6},{1,4,5,7},{-2}}; 遍历该二维数组，并得到和
思路
1. 遍历二维数组，并将各个值累计到 int sum
*/
    int arr[][]= {{4,6},{1,4,5,7},{-2}};
    int sum = 0;
    for(int i = 0; i < arr.length; i++) {
//遍历每个一维数组
    for(int j = 0; j < arr[i].length; j++) {
    sum += arr[i][j];
    }
}
	System.out.println("sum=" + sum);
	}
}

二维数组使用细节和注意事项

1) 一维数组的声明方式有:

int[] x 或者 int x[]

2) 二维数组的声明方式有:

int y 或者 int[] y[] 或者 int y

3) 二维数组实际上是由多个一维数组组成的，它的各个一维数组的长度可以相同，也可以不相同。比如： map 是一个二维数组

int map = {{1,2},{3,4,5}}

由 map[0] 是一个含有两个元素的一维数组 ，map[1] 是一个含有三个元素的一维数组构成，我们也称为列数不等的二维数组