目录
一、数组
1.数组的概述
1.数组的理解
数组(Array)，是多个相同类型数据一定顺序排列的集合，并使用一个名字命名,并通过编号的方式对琼些数据进行统一管理。
2.数组相关的概念:
数组名 元素 角标、下标、索引 数组的长度:元素的个数
3.数组的特点:
1数组是序排列的 2数组属于引用数据类型的变量。
3.数组的元素，既可以是基本数据类型，也可以是引用数据类型3创建数组对象会在内存中开辟一整块连续的空间 4.数组的长度一旦确定，就不能修改。
4．数组的分类:
照维数: 一维数组、二维数组... 照数组元素的类型: 基本数据类型元素的数组、引用数据类型元素的数组
2.一维数组的初始化
数组一旦初始化，其长度就是确定的。
数组的长度一旦确定，就不可修改。
//一维数组的初始化
//动态初始化
int[] Arr = new int[5];
//静态初始化
String[] arr = new String[]{"Tom","Mike","Lily"};3.二维数组的初始化
//二维数组的初始化
//静态初始化
int[][]arr1=new int[][]{{1,2},{2,3},{3,4}};
//动态初始化
int[][]arr2 =new int[4][5];
int[][]arr3=new int[6][];*4.遍历二维数组
//二维数组的遍历
int[][]arr1=new int[][]{{1,2},{2,3},{3,4}};
for(int i=0;i<arr1.length;i++){
for(int j=0;j<arr1[i].length;j++)
System.out.println(arr1[i][j]+"\n");
}5.不同类型的数组元素的默认初始化值
i.一维数组
整型：0
浮点型：0.0
char类型：0
boolean类型：false
引用类型：null
ii.二维数组
//规定:二维数组分为外层数组的元素，内层数组的元素
int[][] arr = new int[4][3];
//外层元素:anr[0], arr[1]等
//内层元素:arx[0][1],anr[1][2]等
//数组元素的默认初始化值
//针对于初始化方式一:比如:
int[][ ]arr = new int[4][3];
/*外层元素的初始化值为:地址值
内层元素的初始化值为:与一维数组初始化情况相同*/
//针对于初始化方式二:比如:
int[][]arr = new int[4][];
/*外层元素的初始化值为:nul1
内层元素的初始化值为:不能调用，否则报错。*/6.一维数组的内存解析
7.数组中涉及的常见算法
1.数组元素的赋值(杨辉三角、回形数等) 2.求数值型数组中元素的最大值、最小值、平均数、总和等 3.数组的复制、反转、查找(线性查找、二分法查找) 4.数组元素的排序算法
i. 数组元素的赋值(杨辉三角、回形数等)
ii.求数值型数组中元素的最大值、最小值、平均数、总和等
***获取随机数的方法
// 获取10个任意的两位数
//两位数的范围是10-99 （a——b）
//获取随机数的公式为：(int)(Math.random()*(b-a+1)+a);
int[]arr=new int[10];
for(int i=0;i<arr.length;i++){
arr[i]=(int)(Math.random()*(99-10+1)+10);
}iii.数组的复制、反转、查找(线性查找、二分法查找)
a.数组的复制
package text;
public class arrtext {
public static void main(String[]args){
// 获取10个任意的两位数
//两位数的范围是10-99 （a——b）
//获取随机数的公式为：(int)(Math.random()*(b-a+1)+a);
int[]arr1=new int[10];
for(int i=0;i<arr1.length;i++) {
arr1[i] = (int) (Math.random() * (99 - 10 + 1) + 10);
System.out.print(arr1[i]);
}
System.out.println("-------------");
//把arr1数组赋值给arr2数组
int arr2[]=new int[arr1.length];
for(int i=0;i<arr1.length;i++){
arr2[i]=arr1[i];
System.out.print(arr1[i]);
}
}
}b.数组的反转
package text;
public class arrtext {
public static void main(String[]args){
String[]arr1=new String[]{"AA","BB","CC","DD","EE","FF"};
for(int i=0;i<arr1.length;i++){
System.out.print(arr1[i]);
}
System.out.println("-------------");
//数组的反转
// 方式一：
for(int i=0,j=arr1.length-1;i<j;i++,j--){
String temp=arr1[i];
arr1[i]=arr1[j];
arr1[j]=temp;
}
for(int i=0;i<arr1.length;i++){
System.out.print(arr1[i]);
}
}
}c.数组的查找
线性查找
字符串是否相等，不能用==直接来判断，可以使用 字符串.equals（）方法
package text;
public class arrtext {
public static void main(String[]args){
String[]arr1=new String[]{"AA","BB","CC","DD","EE","FF"};
for(int i=0;i<arr1.length;i++){
System.out.print(arr1[i]);
}
System.out.println("-------------");
String a="FF";
//这里可以通过 boolean isFlag来判断循环进行等。
boolean isFlag=true;
for(int i=0;i<arr1.length;i++){
//e属于字符串，不能直接用“=”等号，所以需要使用equals
if(a.equals(arr1[i])){
System.out.print("找到了元素FF的位置，它的位置在："+i);
isFlag = false;
break;
}
}
if(isFlag) {
System.out.print("没有找到了元素FF的位置");
}
}
}二分法查找
package text;
public class arrtext {
public static void main(String[] args) {
int[] arr1 = new int []{1,3,5,7,9,11,13,15,17,19,21};
for (int i = 0; i < arr1.length; i++) {
System.out.print(arr1[i]);
}
System.out.println("-------------");
int a=11;
int head=0;
int end=arr1.length-1;
boolean isFlag=true;
while(head<end){
int middle=(head+end)/2;
//注意这里，要比较的是arr1[middle],而不是普通的middle
if(a==arr1[middle]) {
System.out.println("找到要找到的元素了，他的位置是：" + middle);
isFlag=false;
break;
}
if(a<arr1[middle]){
end=middle-1;
}
else{
head=middle+1;
}
}
while(isFlag){
System.out.println("没有找到要找到的元素了");
}
}
}*iv. 数组元素的排序算法（ 冒泡排序、快速排序）
十大排序算法
选择排序: 直接选择排序、堆排序 交换排序: 冒泡排序、快速排序 插入排序: 直接插入排序、折半插入排序、Shell排序 归并排序: 桶式排序: 基数排序:
算法概述
算法的五大特性：
输入( input ) 输出( output ) 有穷性（有限性，Finiteness ) 确定性（明确性，Definiteness ) 可行性（有效性，Effectiveness )
冒泡排序：
算法思想：
相邻两个元素之间进行比较，每一轮都会确定一个最大的元素，一共需要比较数组长度-1轮，才能够确定最终的排序顺序。（大轮）
因为每轮都会确定一个最大的元素，所以后面已经确定的元素不用比较 ，所以这里内层的相邻元素的比较 的尾应该是数组长度-1-i（内层小轮）
package text;
public class arrtext {
public static void main(String[] args) {
int[] arr1 = new int[]{9,45,1,56,89,29,21,2,34,8};
for (int i = 0; i < arr1.length; i++) {
System.out.print(arr1[i]+" ");
}
System.out.println("-------------");
//冒泡排序
//算法思想：相邻两个元素之间进行比较，每一轮都会确定一个最大的元素，一共需要比较数组长度-1轮，才能够确定最终的排序顺序
//大轮循环排序
for(int i=0;i<arr1.length-1;i++){
//内层之间相邻两个元素进行对比
//因为每轮都会确定一个最大的元素，所以后面已经确定的元素不用比较 ，所以这里内层的相邻元素的比较 的尾应该是arr1.length-1-i
for(int j=0;j<arr1.length-1-i;j++){
//相邻两个元素进行比较
if(arr1[j]>arr1[j+1]){
int temp= arr1[j+1];
arr1[j+1]=arr1[j];
arr1[j]=temp;
}
}
}
for (int i = 0; i < arr1.length; i++) {
System.out.print(arr1[i]+" ");
}
}
}快速排序：2的n次方
8. Arrays工具类的使用
| 1 | boolean equals(int[a,int[] b) | 判断两个数组是否相 |
|---|---|---|
| 2 | String toString(int[]a) | 输出数组信息。 |
| 3 | void fill(int[]a,int val) | 将指定值全部替换到数组之中。 |
| 4 | void sort(int[]a) | 对数组进行排序。 |
| 5 | int binarySearch(int[]a,int key) | 对排序后的数组进行二分法检索指定的值。 |
package text;
import java.util.Arrays;
public class arrtext {
public static void main(String[] args) {
int[] arr1 = new int[]{9,45,1,56,89,29,21,2,34,8};
int[] arr2 = new int[]{1,45,9,56,89,29,21,2,34,8};
//| 1 | boolean equals(int[a,int[] b) | 判断两个数组是否相 |
boolean isFlag=Arrays.equals(arr1,arr2);
System.out.println(isFlag);
System.out.println("——————————");
//| 2 | String toString(int[]a) | 输出数组信息。 |
Arrays.toString(arr1);
System.out.println( Arrays.toString(arr1));
System.out.println("——————————");
//| 3 | void fill(int[]a,int val) | 将指定值替换到数组之中。 |
Arrays.fill(arr2,10);
Arrays.toString(arr2);
System.out.println( Arrays.toString(arr2));
System.out.println ("——————————");
//| 4 | void sort(int[]a) | 对数组进行排序。 |
Arrays.sort(arr1);
Arrays.toString(arr1);
System.out.println( Arrays.toString(arr1));
System.out.println ("——————————");
//| 5 | int binarySearch(int[]a,int key) | 对排序后的数组进行二分法检索指定的值。 |
int a= Arrays.binarySearch(arr1,9);
//这里使用if是因为，如果数组中没有找到这个元素的位置时，就会输出负数，所以为了让大家直观地看到这种情况，我们在找不到时，进行 输出语句提示。
if(a>=0){
System.out.print("a元素的位置在："+a);
}else{
System.out.print("该序列中没有找到该元素。");
}
}
}9.数组使用中的常见异常
1．数组角标越界的异常: ArrayIndexOutOfBounasEXcet1on
长度为[0——arr.length-1]
2．空指针异常: NullPointerException
241
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
