每日一语：路在脚下，梦在远方，只要一息尚存，就绝不会放弃。
前言：
引用的狂神Java基础视频——狂神Java基础视频?
目录
?
数组概述
1.数组的定义：
数组是类型相同的有序集合。
数组是描述相同类型的若干个数据，按照一定的先后次序排列组合而成。
其中每一个数据称作数组元素，可以通过下标来访问其元素。?
2.数组的四个基本的特点：
1.数组的长度是确定的，一旦被创建，他的大小就是不能被改变的。
2.其元素类型必须相同，不能出现混合类型。
3.数组中的元素可以是任何的数据类型，可以是基本类型也可以是引用类型。
4.数组是引用类型，数组也可以看作对象，数组中的成员变量相当于该对象的成员变量，数组本身就是对象，Java对象是在堆中的，所以数组无论是保存原始类型还是其他类型，数组本身就是在堆里。?
数组声明创建
1.声明数组：
dataType[] arrayRefVar; // 首选的方法
或
dataType arrayRefVar[]; // 效果相同，但不是首选方法
double[] myList; // 首选的方法
或
double myList[]; // 效果相同，但不是首选方法2.创建数组
Java语言使用new操作符来创建数组?，语法如下：
?
arrayRefVar = new dataType[arraySize];?以上语法做了两件事：
1.使用dataType[arraySize]创建了一个数组。
2.把数组赋值给变量arrayRefVar。
数组是通过索引访问的，从0到array.length-1.
获取数组的长度语法为：
array.length
【演示创建一个数组，并赋值和进行访问】
public class java1 {
public static void main(String[] args) {
int[] nums = new int[5];
nums[0] = 1;
nums[1] = 2;
nums[2] = 3;
nums[3] = 4;
nums[4] = 5;
int sum = 0;
for (int l = 0; l < nums.length; l++) {
sum += l;
}
System.out.println("总和为"+sum);
}
}结果：
3.内存分析
?Java内存分析：
1.声明的时候并不会实例化任何对象，只有在实例化数组对象的时候，JVM才会分配空间，这是才和长度有关，因此声明数组的时候不能指定其长度，错误示范： int a[5]。
2.声明一个数组的时候，数组并没有被真正的创建。
3.构造一个数组必须声明其长度。
//1.声明一个数组
int[] myList = null;
//2.创建一个数组
myList = new int[10];
//3.像数组中存值
myList[0] = 1;
myList[1] = 2;
myList[2] = 3;
myList[3] = 4;
myList[4] = 5;
myList[5] = 6;
myList[6] = 7;
myList[7] = 8;
myList[8] = 9;
myList[9] = 10;
?4.三种初始化
静态初始化
int[] a = {1,2,3};
Man[] mans = {new Man(1,1),new Man(2,2)};动态初始化
int[] a = new int[2];
a[0]=1;
a[1]=2;数组的默认初始化
public static void main(String[] args) {
int[] a=new int[2];
boolean[] b = new boolean[2];
String[] s = new String[2];
System.out.println(a[0]+":"+a[1]); //0,0
System.out.println(b[0]+":"+b[1]); //false,false
System.out.println(s[0]+":"+s[1]); //null, null
}5.数组边界
下标的合法区间：[0, length-1]，如果越界就会报错；?
public static void main(String[] args) {
int[] a=new int[2];
System.out.println(a[2]);
}
?6.小结
数组的使用
1.For-Each
JDK1.5引进了一种新型循环类型，被称为For-Each循环或者加强型循环，它们在不使用下标的情况下遍历数组。
语法格式为：
?
for(type element: array){
System.out.println(element);
}【示例】
public static void main(String[] args) {
double[] myList = {1.9, 2.9, 3.4, 3.5}; // 打印所有数组元素
for (double element: myList) {
System.out.println(element);
}
}2.数组作为方法传入
数组可以做参数传递给方法。
例如下面一个例子就是打印数组：
public static void printArray(int[] array) {
for (int i = 0; i < array.length; i++) {
System.out.print(array[i] + " ");
}
}3.数组做返回值
public static int[] reverse(int[] list) {
int[] result = new int[list.length];
for (int i = 0, j = result.length - 1; i < list.length; i++, j--) {
result[j] = list[i];
}
return result;
}上述例子中result作为数组返回。?
多维数组
多维数组可以看作是数组的数组，比如一个二维数组就是一个一维数组组成的一维数组。
1.多维数组的动态初始化（以二维数组为例）
type[][] typeName = new type[typeLength1][typeLength2];2.多维数组的引用（以二维数组为例）
int a[][] = new int[2][3];其实二维甚至多维数组十分好理解，我们把两个或者多个值当做定位就好。
依次理解就可以。
3.获取数组长度：
Arrays 类
数组中的工具类java.util.Arrays。
由于数组对象本身并没有什么方法可以供我们调用,但API中提供了一个工具类Arrays供我们使用,从
文档简介
Arrays类中的方法都是static修饰的静态方法,在使用的时候可以直接使用类名进行调用,而"不用"使用对象来调用(注意:是"不用" 而不是 "不能")
?java.util.Arrays 类能方便地操作数组. 使用之前需要导包！
具有一下常用功能：
1.给数组赋值：通过 fifill 方法。
2.对数组排序：通过 sort 方法,按升序。
3.比较数组：通过 equals 方法比较数组中元素值是否相等。
4.查找数组元素：通过 binarySearch 方法能对排序好的数组进行二分查找法操作。
?【具体说明请看下表】
?1.打印数组
public class java1 {
public static void main(String[] args) {
int[] nums = new int[5];
nums[0] = 1;
nums[1] = 2;
nums[2] = 3;
nums[3] = 4;
nums[4] = 5;
System.out.println(Arrays.toString(nums));
}
}?
2.数组排序
对指定的 int 型数组按数字升序进行排序
public class java1 {
public static void main(String[] args) {
int[] nums = new int[5];
nums[0] = 1;
nums[1] = 6;
nums[2] = 55;
nums[3] = 15;
nums[4] = 45;
System.out.println(Arrays.toString(nums));
Arrays.sort(nums);
System.out.println(Arrays.toString(nums));
}
}?输出：
?3.二分查找
在数组中查找指定元素并返回其下标
注意：使用二分搜索法来搜索指定的数组，以获得指定的值。必须在进行此调用之前对数组进行排序(通过sort方法等)。如果没有对数组进行排序，则结果是不确定的。
?如果数组包含多个带有指定值的元素，则无法保证找到的是哪一个。
public class java1 {
public static void main(String[] args) {
int[] nums = new int[5];
nums[0] = 1;
nums[1] = 6;
nums[2] = 55;
nums[3] = 15;
nums[4] = 45;
Arrays.sort(nums);
System.out.println("该元素的索引"+Arrays.binarySearch(nums,45));
}
}?输出：
4.元素填充
public class java1 {
public static void main(String[] args) {
int[] nums = new int[5];
nums[0] = 1;
nums[1] = 6;
nums[2] = 55;
nums[3] = 15;
nums[4] = 45;
Arrays.sort(nums);
Arrays.fill(nums,2,3,100);
System.out.println(Arrays.toString(nums));
}
}?输出：
5.数组转换为List集合
List<int[]> list = Arrays.asList(nums);冒泡排序
public class java1 {
public static void main(String[] args) {
int[] nums = new int[5];
nums[0] = 1;
nums[1] = 6;
nums[2] = 55;
nums[3] = 15;
nums[4] = 45;
int [] b = sort(nums);
System.out.println(Arrays.toString(b));
}
public static int[] sort(int[] nums){
int temp = 0;
for (int i = 0; i<nums.length-1 ; i++) {
for(int j = 0 ; j < nums.length - i-1 ; j++){
if (nums[j] > nums[j+1]){
temp = nums[j];
nums[j] = nums[j+1];
nums[j+1] = temp;
}
}
}
return nums ;
}
}输出：
