初始java~数组1(数组的基本概念)

1. 什么是数组

数组：可以看成是相同类型元素的一个集合。在内存中是一段连续的空间。

1. 数组中存放的元素其类型相同
2. 数组的空间是连在一起的
3. 每个空间有自己的编号，起始位置的编号为0，即数组的下标/索引。

数组的使命是用来存储一组相同类型得数据

2. 数组的创建

T[] 数组名 = new T[N];

1. T：表示数组中存放元素的类型
2. T[]：表示数组的类型
3. N：表示数组的长度
   数组的三种创建形式

 		int[] array = {0};
        int[] array2 = new int[]{1, 2, 3, 4, 5, 6};
        int[] array3 = new int[10];

一般第一个创建形式最为常见

int[] array1 = new int[10]; // 创建一个可以容纳10个int类型元素的数组
double[] array2 = new double[5]; // 创建一个可以容纳5个double类型元素的数组
String[] array3 = new String[3]; // 创建一个可以容纳3个字符串元素的数组

不同形式的数据类型表示的数组类型也不同

我们一般通过 new 关键字 实例化对象
java当中的数组 其实就是一个对象 分配内存
所以我们认为java当中 一切皆对象

3. 数组的初始化

数组的初始化主要分为动态初始化以及静态初始化。

1. 动态初始化

概念: 在创建数组时，直接指定数组中元素的个数

int[] array = new int[10];

2. 静态初始化：

概念: 在创建数组时不直接指定数据元素个数，而直接将具体的数据内容进行指定
语法格式： T[] 数组名称 = {data1, data2, data3, …, datan};
例子:

int[] array1 = new int[]{0,1,2,3,4,5,6,7,8,9};//int类型
double[] array2 = new double[]{1.0, 2.0, 3.0, 4.0, 5.0};//double类型
String[] array3 = new String[]{"hell", "Java", "!!!"};//字符串类型

【注意事项】
静态初始化虽然没有指定数组的长度，编译器在编译时会根据{}中元素个数来确定数组的长度。
静态初始化时, {}中数据类型必须与[]前数据类型一致。
静态初始化可以简写，省去后面的new T[]。

// 注意：虽然省去了new T[], 但是编译器编译代码时还是会还原
int[] array1 = {0,1,2,3,4,5,6,7,8,9};
double[] array2 = {1.0, 2.0, 3.0, 4.0, 5.0};
String[] array3 = {"hell", "Java", "!!!"};

在java中也可以写成C语言那种方式，但是不推荐

静态和动态初始化也可以分为两步，但是省略格式不可以。

//可以转变成这样
int[] array1;
array1 = new int[10];
int[] array2;
array2 = new int[]{10, 20, 30};

//这样写是不可能的
 int[] array4;
 array4 = {1，2，3，4}；
//如果不能一行写完，就不能省略new int[]
//省略格式不可以拆分, 否则编译失败

在Java中，如果没有对数组进行初始化，数组中元素有其默认值

1. 如果数组中存储元素类型为基类类型，默认值为基类类型对应的默认值:
   
2. 如果数组中存储元素类型为引用类型，默认值为null

4. 数组的使用

1.数组中元素访问

数组在内存中是一段连续的空间，空间的编号都是从0开始的，依次递增，该编号称为数组的下标，数组可以通过下标访问其任意位置的元素

public static void main3(String[] args) {
        int[] array2 = new int[]{1, 2, 3, 4, 5, 6};
         System.out.println(array2[0]);
        //我们可以通过[]对数组中的元素进行修改
        array2[0] = 99;
        System.out.println(array2[0]);
    }

结果:

【注意事项】

1. 数组是一段连续的内存空间，因此支持随机访问，即通过下标访问快速访问数组中任意位置的元素
2. 下标从0开始，介于[0, N）之间不包含N，N为元素个数，不能越界，否则会报出下标越界异常。

int[] array = {1, 2, 3};
System.out.println(array[3]); // 数组中只有3个元素，下标一次为：0 1 2，array[3]下标越界
// 执行结果
Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: 3
	at Test2.main(Test2.java:6)

2. 遍历数组

“遍历” 是指将数组中的所有元素都访问一遍, 访问是指对数组中的元素进行某种操作

例如:

int[]array = new int[]{10, 20, 30, 40, 50};
System.out.println(array[0]);
System.out.println(array[1]);
System.out.println(array[2]);
System.out.println(array[3]);
System.out.println(array[4]);

int[]array = new int[]{10, 20, 30, 40, 50};
for(int i = 0; i < 5; i++){
System.out.println(array[i]);
}

这两段代码执行的结果是相同的，但是通过第二种可以发现在通过每一次的循环可以把所有的函数都表达出来。

在这里很难确定的是数组的长度？
这时我们引入了一个类通过（数组对象.length）来表示数组长度

int[]array = new int[]{10, 20, 30, 40, 50};
for(int i = 0; i < array.length; i++){
System.out.println(array[i]);
//结果是 10 20 30 40 50 
}

这里也可以使用 for-each来遍历数组

public static void main(String[] args) {
        int[] array = new int[]{1, 2, 3, 4, 5, 6};
        for (int x : array) {
            System.out.print(x+" ");
       }
    }

结果:

for-each的解析

在这里还可以通过Arrays.toString(数组对象)来将数组转换成字符串。

在使用Arrays.toString(数组对象)需要拿String来接收

 public static void main(String[] args) {
        int[] array = new int[]{1, 2, 3, 8, 5, 6};
        String ret = Arrays.toString(array);//将字符转换成字符串
        System.out.println(ret);
 }

结果:

将不同的类型数组内容转变成字符串

注意他的返回类型

3. 数组的排序

我们通过Arrays.sort(数组对象)来进行数组的排序

 int[] array = new int[]{1, 2, 3, 8, 5, 6};
    	System.out.print("排序之前: ");
        for (int i = 0; i < array.length; i++) {
          	System.out.print(array[i]+" ");
        }//通过下标来实现
        System.out.println();
		Arrays.sort(array);//排序
		System.out.print("排序之后: ");
        for (int i = 0; i < array.length; i++) {
            System.out.print(array[i]+" ");
        }//通过下标来实现

Arrays.sort不同使用类型

在Arrays.sort中可以传进去的参数有两种1. sort(char[] a)(上面已经表示出来是全部数组的升序) 2.sort(char[] a,int fromIndex,int toIndex)

fromIndex表示要排序第一个索引(下标)
toIndex表示的是最后一个要排序的元素的索引(下标)
例子:

 public static void main(String[] args) {
        int[] array = new int[]{2,3,6,5,1,4,7};
        Arrays.sort(array,3,array.length);
        String ret =Arrays.toString(array);
        System.out.println(ret);
    }

结果:

从第三个下标到最后一个下标的数进行了排序，其他位置没有发生变化。

以上内容如果对诸位有帮助的话可以留下你们的赞赞，如果我书写的有问题，请在评论区指出，我会及时修改的。