数组和Arrays工具类

一、数组声明和初始化

方式一：数据类型[] 数组名 int[] arr(推荐)
方式二：数据类型 数组名[] int arr[]

初始化

Java中的数组必须先初始化，然后才可以使用，所谓初始化，就是为数组中的数组元素分配内存空间，并为每个数组元素赋初始值。

动态初始化

初始化时程序员只指定数组长度，由系统为数组元素分配初始值。
语法：元素类型[ ] 数组名 = new 元素类型[元素个数或者数组长度]；
int [] arr = new int[10];
系统对初始值分配规则如下：
a.整数型为0
b.浮点型为0.0
c.字符型为‘\u0000’(不同的系统平台显示结果不同)
d.布尔类型为false
e.引用类型为null

示例

/*
动态初始化：初始化时由程序员指定数组的长度，系统负责分配元素的初始值
*/
int[] array1 = new int[5];//0
String[] array2 = new String[3];//null
char[] array3 = new char[10];//\u0000

注意：
a.在初始化数组时，不要静态初始化和动态初始化同时使用，也就是说，不要在进行数组初始化时，既指定数组的长度，也为每个数组元素分配初始值。

静态初始化

初始化时由程序员指定每个数组元素的初始值，由系统自动计算数组长度。

语法：数组元素类型[] 数组名 = new 数组元素类型[]{元素0，元素1,…};
double[] scoresArr2 = new double[]{11,33,44,55,66};

可简写为：数组元素类型[] 数组名 = {元素0，元素1,…};
int[] arr = {11,33,44,55,66};
说明：任何一个变量都得有自己的数据类型，这里的arr表示数组变量名称，int表示数组中元素的类型，int[]才是数组类型

注意：简写静态初始化只能一条语句完成，不能分割成两条语句。
示例：

		/*
		静态初始化:由我们指定元素的初始值，由系统计算长度或者元素的个数
		*/
		int[] arr = new int[]{1,56,76,87};
		int[] arr1 = {1,56,76,87};

		String[] arr2 = new String[]{"434","gfg","gjf545"};
		String[] arr3 = {"434","gfg","gjf545"};

		char[] arr5 = new char[]{'2','g','*'};
		//char[] arr5 ={'2','g','*'};

二、数组的使用

注意：
1 Java语言的数组索引(下标、角标)是从0开始的,数组的下标的最大值 长度-1
2不要超出索引的范围，如果超出范围出现异常 java.lang.ArrayIndexOutOfBoundsException

示例()

		//使用静态初始化的方式定义一个数组
		//数组中可以存放重复数据
		int[] arr1 = new int[]{2,65,76,83,32,5,5};
		//1.访问数组中的元素
		//格式：数组名称[下标] 表示获取指定下标所对应的值
		//需求：获取下标3对应的元素
		int num1 = arr1[3];
		System.out.println(num1);//83
		System.out.println(arr1[3]);//83
		
		//2.获取数组中的元素个数或者数组的长度
		//格式:数组名称.length;
		System.out.println("数组arr1的长度为：" + arr1.length);
		

		//3.修改数组元素的值
		int num2 = arr1[6];
		System.out.println(num2);//
		//格式：数组名称[下标] = 被修改之后的值
		//注意：不管是静态初始化还是动态初始化，都可以采用这种方式修改元素的值
		arr1[6] = 100;
		System.out.println(arr1[6]);//100

遍历数组示例

方式一：简单for循环
方式二：增强for循环（foreach）无法使用下标

		int[] arr1 = new int[] { 2, 65, 76, 83, 32, 5, 5 };
	
		// 遍历数组(for循环)
		for (int i = 0; i < arr1.length; i++) {
			int n = arr1[i];
			System.out.println(n);
		}
		/*
		 * 遍历数组(foreach) JDK1.5之后新增的 优点：用于遍历数组和集合，无需通过数组下标，就可以直接访问数组或者集合中的元素。 语法：
		 * for(元素数据类型 变量名：数组名称) { System.out.println(变量名); }
		 */
		// 底层工作原理：根据下标获取数组元素
		for (int num : arr1) {
			System.out.println("增强for循环的结果：" + num);
		}
		/*
		 * 两种遍历方式的选择：不需要知道下标，只需要获取元素值，则采用增强for循环
		 */
		// 需求：打印下标为偶数的元素值【只能采用简单for循环】
		for (int i = 0; i < arr1.length; i++) {
			if (i % 2 == 0) {
				int n = arr1[i];
				System.out.println(n);
			}
		}
	}
}

获取数组的最大值和最小值以及下标

public class arrayTest1 {
	public static void main(String[] args) {
		//1、定义一个数组
		int [] scores = {89,78,98,67,75,45,89};
		//2、取出最大值和最小值
//		int max = scores[0];
//		int min = scores[0];
//		for(int score :scores){
//			if(score > max){
//				max = score;
//			}
//			if(score<min){
//				min = score;
//			}
//		}
		//3、获取最大值和最小值的索引
		int maxIndex = 0;
		int minIndex = 0;
		for (int i = 0; i < scores.length; i++) {
			if(scores[maxIndex]<scores[i]){
				maxIndex = i;
			}
			if(scores[minIndex]>scores[i]){
				minIndex = i;
			}
		}
		//4、输出最大值和最小值
		//System.out.println("max="+maxIndex);//2
		//System.out.println("min="+minIndex);//5
		System.out.println("scores["+maxIndex+"]="+scores[maxIndex]);
		System.out.println("scores["+minIndex+"]="+scores[minIndex]);
	}
}

数组应用–从数组中删除指定元素

public class arrayTest2 {
	public static void main(String[] args) {
		//定义数组
		int [] scores = {89,78,98,67,75,45,89};
		
		//删除之前的数组输出
		System.out.println("删除前");
		for (int score : scores) {
			System.out.print(score+"\t");
		}
		System.out.println();
		//删除
		//1定位指定值的索引（先不考虑指定值的索引）
		int val = 89;
		int index =10;
		for(int i=0;i<scores.length;i++){
			if(scores[i]==val){
				index = i;
				break;
			}
		}
		//2将指定索引后面的元素都前移一个位置		
		for(int i=index;i<scores.length-1;i++){
			scores[i]=scores[i+1];
		}
		//3删除数组的最后一个元素
		if(index>=0 && index<scores.length){
			scores[scores.length-1]=0;
		}
		
		//输出删除后的数组
		System.out.println("删除后");
		for (int score : scores) {
			System.out.print(score+"\t");
		}
	}

}

数组应用–向数组中添加元素

public class arrayTest3 {
	public static void main(String[] args) {
		//定义数组
		//int [] scores = {89,78,98,67,75,45,89,0,0,0};
		int [] scores = {20,45,56,67,78,98,100};
		//添加之前的数组输出
		System.out.println("添加前");
		for (int score : scores) {
			System.out.print(score+"\t");
		}
		System.out.println();
		//添加
		//1确定要添加值的索引
		int index = 2;
		int val = 111;
//		 for(int i=0;i<scores.length;i++){
//			 if(scores[i]>val){
//				 index = i;
//				 break;
//			 }
//		 }
		//2将指定索引的后面元素都后移一个位置（ 从后向前）
		for(int i=scores.length-2;i>=index;i-- ){
			scores[i+1] = scores[i];
		}		
		//3在指定位置添加元素
		scores[index]=val;
		//输出添加后的数组
		System.out.println("添加后");
		for (int score : scores) {
			System.out.print(score+"\t");
		}
	}
}

数组的总结

数组的内存分配图 （数组也是引用数据类型）

• 数组属于引用类型，数组引用变量只是一个引用，这个引用变量可以指向任何有效的内存空间，只有当这个引用指向有效的空间时，才可以通过引用去操作真正数组中的元素。
• 数组的引用变量存储在栈空间中，而真正的数组数据存储在堆空间在中。
  

数组的特点

• 数组的长度是固定的，一经定义，不能再发生变化（数组的扩容）
• 每个数组元素有默认值
• 数组会在内存中开辟一块连续的空间

示例1

键盘录入java成绩，并把成绩保存在数组中，然后计算总分和平均分

import java.util.Scanner;

public class TestArray {
	public static void main(String[] args) {
		Scanner input = new Scanner(System.in);
		System.out.println("请输入总人数");
		int count = input.nextInt();
		int[] score = new int[count];
		for (int i = 0; i < score.length; i++) {
			System.out.println("请输入第" + (i + 1) + "个人的java成绩");
			score[i] = input.nextInt();
		}
		System.out.println("-------------------");
		int sum = 0;// 总分
		double avg = 0;// 平均分
		for (int n : score) {
			sum = sum + n;
		}
		avg = (double) sum / count;
		System.out.println("总分是:" + sum);
		System.out.println("平均分是:" + avg);
	}
}

java内存

java内存	作用	特点
栈	存储基本类型数据和引用类型的地址	先进后出，一般空间比较小，存取速度较快，局部变量和自定义对象的引用存储在栈中
堆	存储引用类型数据	空间比较大，存储速度相对较慢，成员变量和对象存储在堆中，被所有的线程共享
方法区	存储字符串常量池，静态数据，代码和类的元数据	又叫静态区，跟堆一样，被所有的线程共享。方法区包含所有的class和static变量；方法区中包含的都是在程序中永远的唯一的元素

使用数组时常见的问题

数组越界异常：ArrayIndexOutofBoundsException

出现的时机：当使用了不存在的下标时，则会出现这个错误
0~length – 1

public class ArrayIndexOut {
	public static void main(String[] args) {
		int[] arr = new int [5];
		//arr[5]下标越界
		for (int i = 0; i < 6; i++) {
			System.out.println(arr[i]);
		}
		//解决
		//for (int i = 0; i < arr.length; i++) {
		//	System.out.println(arr[i]);
		//}
	}
}

空指针异常：NullPointerException

出现的时机：当数组的引用变量赋值为null，还在后面的代码中使用这个引用

public class arrayNullPointer {
	public static void main(String[] args) {
		String[] names=new String[5];
		for (int i = 0; i < names.length; i++) {
			if (names[i].equals("CSDN")){//会报错java.lang.NullPointerException
			//解决办法1. "CSDN".equals(names[i])
			//条件换为2. name[i]!=null&&names[i].equals("CSDN")
				System.out.println("ok");
				break;
			}
		}
	}
}

总结：

数组的缺点：
在数组中添加或删除数据，会大量移动数据在内存中的位置，影响性能或效率！

优点：
按照索引去查询数据非常快，效率非常高！通过计算获取数据！

三、冒泡排序，选择排序，二分查找

冒泡排序

排序思路：比较两个相邻的下标对应的元素，如果符合条件就交换位置（最值出现在最后位）

import java.util.Arrays;

public class BubbleSort{
	public static void main(String[] args) {
		int [] scores = {89,78,98,67,75,45,89,99,65,31};
		BubbleSort b = new BubbleSort();
		int [] arr = b.sort(scores);
		for (int i = 0; i < arr.length; i++) {
			System.out.print(arr[i] + " ");
		}
}
    public int[] sort(int[] sourceArray){
        // 对 arr 进行拷贝，不改变参数内容
        int[] arr = Arrays.copyOf(sourceArray, sourceArray.length);

        for (int i = 1; i < arr.length; i++) {
            // 设定一个标记，若为true，则表示此次循环没有进行交换，也就是待排序列已经有序，排序已经完成。
            boolean flag = true;

            for (int j = 0; j < arr.length - i; j++) {
                if (arr[j] > arr[j + 1]) {
                    int tmp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = tmp;

                    flag = false;
                }
            }
            if (flag) {
                break;
            }
        }
        return arr;
    }
}

选择排序

排序思路：固定一个下标，然后拿这个下标对应的值依次和后面的元素进行比较

import java.util.Arrays;

public class BubbleSort {
	public static void main(String[] args) {
		int[] scores = { 89, 78, 98, 67, 75, 45, 89, 99, 65, 31 };
		BubbleSort b = new BubbleSort();
		int[] arr = b.sort(scores);
		for (int i = 0; i < arr.length; i++) {
			System.out.print(arr[i] + " ");
		}
	}

	public int[] sort(int[] sourceArray) {
		int[] arr = Arrays.copyOf(sourceArray, sourceArray.length);

		// 总共要经过 N-1 轮比较
		for (int i = 0; i < arr.length - 1; i++) {
			int min = i;

			// 每轮需要比较的次数 N-i
			for (int j = i + 1; j < arr.length; j++) {
				if (arr[j] < arr[min]) {
					// 记录目前能找到的最小值元素的下标
					min = j;
				}
			}

			// 将找到的最小值和i位置所在的值进行交换
			if (i != min) {
				int tmp = arr[i];
				arr[i] = arr[min];
				arr[min] = tmp;
			}

		}
		return arr;
	}
}

二分查找

查找思路：前提是数组是有序（升序或者降序）的，通过折半来缩小查找范围，提高查找效率，将待查找的元素与中间下标对应的元素比较，如果大于中间下标对应的元素，则去右半部分查找。
（图解）

示例：主要是锻炼思路

public class ArraySearch {
	public static void main(String[] args) {
		int[] arr = { 12, 43, 54, 65, 87, 88, 90, 343 };
		//待查找的元素
		int key = 88;
		//相应的下标  0   length-1
		int left = 0;
		int right = arr.length - 1;
		while (left <= right) {
			//中间下标
			int middle = (left + right) / 2;// 取整 4
			if (arr[middle] > key) {
				//在左边 
				right = middle - 1;
			} else if (arr[middle] < key) {
				left = middle + 1;
			} else {
				System.out.println(middle);
				break;
			}
		}
	}
}

四、Arrays工具类

Arrays介绍（具体方法可查看源码）

由于数组自身缺乏相应的方法，仅仅提供一个属性length，所以如果处理数组，通过数组自身去操作是比较麻烦的，java提供了工具类Arrays专门操作数组。

作用：主要用于对数组进行排序，查找，填充，比较等的操作
Arrays工具类存在于java.util包下，所以使用的第一步就是导包：import java.util.Arrays;
1.Java提供的对数组进行操作的工具类
2.构造方法私有 所有方法都是static，只能通过类名来进行访问
3.方法

• 1.Arrays.toString(arr1) //格式化成字符串后输出

• 2.Arrays.binarySearch(arr2, 30);//前提是 有序的数组 二分查找 / 折半查找

• 3.Arrays.sort(arr1);

• 4.Arrays.sort(Object []);

• 5.Arrays.sort(a, compartor);

• 6.Arrays.copyOf(arr1, 9); //数组复制

• 7.Arrays.equals(arr1, arr3) //数组的比较

• 8.Arrays.copyOfRange(arr1, 4, 6); 不包含第6个数据 [4,6)

• 9.Arrays.fill(arr1, 10);//填充数组

• 10.Arrays.fill(arr1, 2, 7, -50);

• 11.Arrays.asList(“Larry”, “Moe”, “Curly”);

示例Arrays工具类使用

import java.util.Arrays;

public class ArraysDemo {
	public static void main(String[] args) {
		binarySearch();
		sort();
		copy();
		fill();
		toStr();
	}

//binarySearch 二分查找
	public static void binarySearch() {
		int[] arr = new int[] { 5, 8, 10, 20, 65, 100 };
		int result = Arrays.binarySearch(arr, 22);
		if (result >= 0) {
			System.out.println("找到了");
		} else {
			System.out.println("没找到 ");
		}
	}

//排序
	public static void sort() {
		int[] arr = new int[] { 12, 8, 100, 2, 9 };
		Arrays.sort(arr);
		System.out.print("排序之后:");
		for (int i = 0; i < arr.length; i++) {
			System.out.print(arr[i] + " ");
		}
		System.out.println();
	}

//复制
	public static void copy() {
		int[] arr = new int[] { 12, 8, 100, 2, 9 };
		int[] arr2 = Arrays.copyOf(arr, arr.length);
		System.out.print("复制数组:");
		for (int i = 0; i < arr2.length; i++) {
			System.out.print(arr2[i] + " ");
		}
		System.out.println();
	}

//填充
	public static void fill() {
		int[] arr = new int[] { 12, 8, 100, 2, 9 };
		Arrays.fill(arr, 10);
		System.out.print("填充数组:");
		for (int i = 0; i < arr.length; i++) {
			System.out.print(arr[i] + " ");
		}
		System.out.println();
	}

//把数组转成字符串
	public static void toStr() {
		int[] arr = new int[] { 12, 8, 100, 2, 9 };
		String s = Arrays.toString(arr);
		System.out.println("数组转成字符串"+s);
	}
}

五、可变参数(JDK5.0后增加的内容)

不定长参数：在设计方法时，方法的形参的个数是不确定的。

注意事项
语法：类型… 变量名称(int … nums)
方法的形参 在方法中可以当做数组进行处理
一个方法只能有一个可变参数
可变参数只能放方法参数列表最后如：sort(int i,int… arr)

import java.util.Arrays;
public class Demo {
	public static void main(String[] args) {
		int[] nums= {10,4,8,20,2};
		int [] arr1 = sort(nums);
		for (int i = 0; i < arr1.length; i++) {
			System.out.print(arr1[i] + " ");
		}
		System.out.println();
		
		// 实际运行是，把这些数据变成数组
		int [] arr = sort(10, 4, 8, 20, 2);
		System.out.println(Arrays.toString(arr));

	}

	public static int[] sort(int... arr) {
		int [] arr1 = new int [arr.length];
		for (int i = 0; i < arr.length - 1; i++) {
			for (int j = 0; j < arr.length - i - 1; j++) {
				if (arr[j] > arr[j + 1]) {
					int temp = arr[j];
					arr[j] = arr[j + 1];
					arr[j + 1] = temp;
				}
			}
		}
		return arr;
	}
}

可以通过可变参数实现多个数相加

 add(int [] nums);
 add(int ... nums);

main方法

main方法为程序的主入口方法
分析： public static void main(String[] args)

• public 权限修饰符 所有包都可以访问
• static 静态的 可以通过类名来访问 ArrayUtil.sort(scores);
• void 没有返回值
• main 方法名
• String [] args 参数列表 参数是一个字符串数组