Java学习笔记二（数组）

一、数组

1、数组的介绍

1. 存储一系列值的容器，必须相同数据类型，并且长度固定。
2. 特点：
   2.1、数组是引用类型
   2.2、数组中所有数据的类型必须一致
   2.3、数组的长度在运行期间不可改变

2、数组的创建

创建引用类型对象，可称之为对象的初始化

1. 动态初始化（指定长度，没有内容）

//动态初始化 创建长度为5的数组
int[] arr = new int[5];

3. 静态初始化（指定内容）

//静态初始
int[] arr2 = new int[]{5,9,8,7,1};
//虚拟机优化后的静态是数组创建方式
int[] arr3 = {5,9,8,7,1};

3、数组的遍历

1. 因为直接打印数组对象时，打印的 是其 全类名+@+地址值，所以如果想要打印数组中的每一个元素，就需要通过循环，对数组的循环打印其中元素，我们称之为 遍历（最基础的遍历就是打印元素）
2. 遍历：重复的，有逻辑的执行同一个操作

//遍历数组
String str = "[";
for (int i = 0; i < arr3.length; i++) {
	str = str + arr3[i] +",";
}
str = str.substring(0,str.length()-1) + "]";
System.out.println(str);

3. 当初始化一个数组时，如果元素没有值，会赋予默认值
   整数型：0
   浮点型：0.0
   布尔型：false
   字符型：’\u0000’ //nuicode码，不可见字符，不是空格
   引用类型：null

4、最大值与最小值

1. 最大值

//1、静态初始化，定义一个数组
int[] arr = {15,4,794,4,15};
//获取数组中每一个元素
//需要定义一个变量用于存储数组中的最大值
int max = arr[0];
for (int i = 0; i < arr.length; i++) {
	if (max < arr[i]){
		max = arr[i];
	}
}
System.out.println("最大值为："+max);

2. 最小值

int min = arr[0];
for (int i = 0; i < arr.length; i++) {
	if (min > arr[i]){
		 min = arr[i];
	}
}
System.out.println("最小值为："+min);

5、排序

1. 冒泡排序：
   通过每次冒泡排序操作相邻两元素进行比较，找出最大或最小，如果满足条件，两元素间位置进行交换，每一次的冒泡都会找出一个元素达到指定位置

int[] arr = {33, 45, 7, 12, 14, 6};

//通过冒泡排序法进行排序
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 t = arr[j];
			arr[j] = arr[j + 1];
			arr[j + 1] = t;
		}
	}
}
System.out.println(Arrays.toString(arr));

2. 选择排序：
   在数组中选择性的找出最值，放置到数组的指定位置，然后再在未操作的元素中重复以上操作的

int[] arr = {78,5,48,14,55,45};
//找最值
for (int i = 1; i < arr.length; i++) {
	//定义一个杯子  存储最值下标
	int max = arr.length-i;
	//通过该循环找出最值
	for (int j = 0; j < arr.length-i; j++) {
		if (arr[max] < arr[j]){
			max = j;
		}
	}
	//进行元素的位置互换
	int t = arr[max];
	arr[max] = arr[arr.length - i];
	arr[arr.length - i] = t;
}
System.out.println(Arrays.toString(arr));

3. 反选排序：
   把数组中的元素顺序反转[1,2,3,4,5]==>[5,4,3,2,1]

int[] arr = {1,2,3,4,5};
for (int i = 0; i < arr.length/2; i++) {
	//位置互换
	int t = arr[i];
	arr[i] = arr[arr.length - i - 1];
	arr[arr.length-i-1] = t;
}
System.out.println(Arrays.toString(arr));

4. 直接插入排序：
   把数组切割成两部分，一部分为有序的，一部分无序，每一次都从无序部分获取一个元素，插入至有序部分，使有序部分每一次都成为一个新的有序数组

int[] arr = {78,5,48,14,55,45};
//遍历数组 小到大
for (int i = 1; i < arr.length; i++) {
	for (int j = i; j > 0; j--) {
		if (arr[j]<arr[j-1]){
			int t = arr[j];
            arr[j] = arr[j-1];
            arr[j-1] = t;
        }
    }
}
System.out.println(Arrays.toString(arr));

5. 5. 快速排序：
      用别给我们写好我方法

int[] arr = {78,5,48,14,55,45};
Arrays.sort(arr);
//指定位置排序[fromIndex,toIndex)
Arrays.sort(arr,1,4);
System.out.println(Arrays.toString(arr));