Java数组

# Java数组在 Test（测试包内）新建一个类，然后在Name中输入新建类的名字 

举例：①Name中输入 Array（开头必须是大写）Test（尾部必须是Test结尾）后面加上编号（01）

#### 数组的写法有三种

在ArrayTest01.java中输入

```
public class ArrayTest01{
```

@Test

（这是一个注解）（如果说报错，鼠标放在Test上悬停会提示你有一个 Import，导入这个包）（点击以后会在上方出现这个包的名字，就是导入成功）（出现的内容是 import org.jupiter.api.test:）

```
    public void test01（）{

​    //int a = 10;

​    //int b = 20;

​    //int c = 30;

​    //也可以写成 int a = 10，b = 20 , c = 30;还可以把他们放在一起，三个值放在一个内存中

​    int[ ] array = {10,20,30};
```

 意思是 int为整数类型，中括号为存放值（数字的容器），array就相当于存放容器的名字(实际是变量)，花括号就是存放的数量（是值）然后分号结尾

//array中文翻译是数组的意思

//相同数据类型的元素组成的集合我们称之为数组

}

}

# 数组赋值与读取

```
@Test

​    public void test 02(){

     int [ ] array = new int [5];

​    //(这个5是数组的长度的意思，只是声明没有赋值)

​    把这个当成一个格子墙，然后这个是有下标的，是从0开是的也就是0为1

​    然后写法为：    

​    array[2] = 20; 

​    //(意思是在array的数组中，第2个下标放入的值为20)

​    输入方式为：

​    System.out.println(array[2]);

​    //(右键运行即可读出这个数组一个等于号为负值符号，两个为比较符号)；
```

# 数组的三种赋值方式

```
    @Test

​    public void test03{

​        int[ ] arr0 = new int [ ] {5};

​    //（花括号不写数字代表没有赋值，写则代表赋值）

​    //（注意花括号中的5代表元素的值，而非长度）

​    int[ ] arr1 = new int [ 5 ] ；

​    //（注意中括号的5代表长度，而非元素的值）

​    int[ ] arr2 = {5}; 

(上面这三个是三种赋值的方式)

 }
```

# 数组下标越界

```
@Test

public void test 04(){

int [ ] array = new int [5];

array[2] = 20; 

System.out.println(array[2]);

(如果说我现在需要取下标为5的数组，但是下标最好多到4，因为是从0开始的，所以怎么办？)  

System.out.println(array[5]);

（整数类型运行会出现报错，并且返回值为0；别的类型返回值也是0但是浮点数返回是0.0，布尔值返回的 false 查尔类型返回 null 字符型是返回一个空字符不代表没有字符，读取没有赋值的位置上的元素，读取到的是该数组类型的默认值）
```

# 数组的数据类型与长度

```
@Test

public void test 05(){

​    String[ ] arr0 = new String[3];

​    arr0[0] = "一";

​    arr0[1] = "二";

​    arr0[2] = "三";

System.out.println(array[0);

System.out.println(array[1]);

System.out.println(array[2]);

(这串代码输出时会自动换行)

变成：                    一

​                               二

​                               三

再重新赋一遍值：arr0 = new String[5];

输出：System.out.println(array[0]);

​            System.out.println(array[1]);

​            System.out.println(array[2]);

（输出结果为null，因为变量指向的空间变了，重新开辟的新空间的叫做引用数据类型，数组一旦声明长度，长度是不可变的）
```

#### 数组特点

（相同数据的元素组成的集合我们称之为数组，数组中能够存储的元素最大值我们称之为该数组的长度，数组声明后该数组的长度不可修改，数组声明后没有赋值的index位置上赋值为该数组类型的初始值默认值）

} 

# 数组的遍历

```
@Test

public void test 06){

​    String[ ] arr0 = new String[3];

​    arr0[0] = "一";

​    arr0[1] = "二";

​    arr0[2] = "三";

​    for （int i = 0； i  <  3;  i ++）{

​        System.out.println(arr0[i]);

(读取下标即可，如果不知道数组长度怎么办？)

​        使用 System.out.00.println（arr0，lenmgth）；

//使用   .length   属性，获取的是该数组的长度，这个不是方法！！！ 

//还可以改成：for （”数组array的长度 >>> “ +arr0.length）;

​                            System.out.println(arr0[i]);

//与上面的一样，这就是数组的遍历

}
```

# Array.toString

#### 数组工具类

```
@Test

public void test 07){

​    String[ ] arr0 = new String[3];

​    arr0[0] = "一";
​    arr0[1] = "二";

​    arr0[2] = "三";

​    System.out.pritln(Arrays);

​                    //(此时Arrays的下标变红，鼠标悬停，然后导包 java.util)

//导入以后，再写一个.然后会出现一个toString的选项，然后就变成

System.out.pritln(Arrays.toString(arr0));

//输出后就会变成【一， 二，三】 
```

# for循环实现Array.toString

（按照这个格式整理）

##### 写法：

    @Test
    public void test 07( ) 
            String[] array = {"一"，"二"，"三"};
            System.out.println(Arays.toString(array));
            System.out.print("[");
            for (int i = 0; i< array.length; i++){
                String string = array [i];
                if (i< array.length - 1){
                    System.out.print(string + ", ");
                }else{
                    System.out.println(string);
                }
            }
            System.out.println("]");
          }

## Questions(Q)问题：

为什么有时候用大写的Array  有时候用小写的array？

.length是什么意思？

为什么一个字符串是S写的S一个是小写的S？

## Answering(A)回答:

.length是属性    一般用来说明数组的长度

.length（）是方法，针对字符串String说的，用来求字符串的长度

## Supplementary(S)补充:

字符串：可以是 数字  字符 汉字 

## Analyze(E)分析:

第一步是建立的void的一个类，然后输入想显示的内容

String是字符串的意思   array是数组的意思  后面跟着的是想输出的字符串内容

第五行是系统输出的意思，为什么后面的print没有ln

* println打印的时候自带了换行，下一次在打印的时候从下一行开始打印。

* print不换行，下次打印的时候在这次打印的东西后面直接打印。

输出一个 [  因为这次的代码就是为了实现上一个代码输出的样式，所以上一个都是在同一行的，这个就模仿上一组代码，需要输出这个

for语句开头 是循环的意思  

输入一个整数类型        他的名字是 i      赋值一个0  它小于array(数组)  然后说明数组的长度，最后判断 i 进行自增1

字符串输出    那个数组  数组名是array       i 是数组的下标   

if语句 进行判断 如果 i （此时是整数类型的数值）小于 数组 ，则下标  -1

输出不换行的  一  然后自增 1 继续输出二  继续自增输出三（这点有点不太懂）

最后是输出一个括号 ]

# foreach 遍历数组

##### 写法：

```
@Test
public void test 08( ) 
        String[] array = {"一"，"二"，"三"};

        for（悬停，然后选择一个叫 foreach的包，回车）（String string : array ）{

                System.out.println (string) ;

}
```

# Arrays.toString

#### 写法：

```
@Test
public void test 09( ) {
        String[ ] array = {"一"，"二"，"三"};

​    //Arryays.toString（array）;

​    //Arryays.to（悬停后点击Arrays - java.util选项)（选择一个toString的选项）

​    //注意运行时点击 JUitl Text运行

​    //此时输出控制台没有任何内容，因为没有输出语句，然后在该方法上Ctrl+1拿一个变量接受即可

​    //然后输出这个字符串

​    String string = Arrays.toString(array);

​    System.out.println(string);

}
```

# 数组合并

两个数组合并成一个新的数组

#### 写法：

```
@Text

public void test 10( ) {

​    int [ ]  arra0 = {0,2,4,6,8};

​    int [ ]  arra1 = {1,3,5,7,9};

//思路：

//1声明一个新的数组，长度是两个数组长度的和

//2将第一个数组循环赋值给新数组

//3将第二个数组循环赋值给新数组，注意：第二个数组赋值时的起始位置

int[ ] arr2 = mew int[arr0.lenth + arr1.lenth];

//遍历第一个数组

for ( int i =0; i < arr0.length; i++){

​    //获取第一个数组中的元素

​    int num = arr0[i];

​    //将获取到的元素赋值给新数组

​    arr2 [ i ]  = num;

}

System.out.println(Arrays.toString(arr2)) ;

//遍历第二个数组

for ( int i =0; i < arr1.length; i++){

//获取第二个数组中的元素

​    int num = arr1[i];

//将获取到的元素赋值给新数组

​    arr2 [ arr0.length + i ]  = num;

//注意第二个数组赋值的歧视位置为第一个数组的长度的下标

//这个位置的意思是从这个arr0的数组的最后一位开始赋值

} 
```

# 数组依次合并

```
@Text

public void test 11( ) {

​    int [ ]  arra0 = {0,2,4,6,8};

​    int [ ]  arra1 = {1,3,5,7,9};

//按照下标相同的位置一次将以上两个数组中的元素插入新的额数组中

//思路：

// 1声明一个新的数组，长度是两个数组长度的和

//2将第一个数组循环赋值给新数组  注意：下标规律为2n

//3将第二个数组循环赋值给新数组，注意：下标规律为2n+1  注意：第二个数组长度如果与第一个数组长度不一致的时候怎么办？

int[ ] arr2 = mew int[arr0.lenth + arr1.lenth];

for (int i = 0; i < arr0.lenth; i++0){

//获取第一个数组的元素    

int a = arr0 [ i ];*

//获取第二个数组相同下标位置上的元素 

int b = arr1 [ i ];

//下标依次赋值                                        //简写：

arr2[ 2 * i] = a;                                                    arr2[ 2 * i] = arr0 [i];

arr2[2 * i + 1] = b;                                               arr2[2 * i + 1] = arr1[i];

}

System.out.println(Arrays.toString(arr2)) ;
```

# 长度不一致的数组依次合并

```
写法：

@Text

public void test 12( ) {

​    int [ ]  arra0 = {0,2};

​    int [ ]  arra1 = {1,3,5,7,9};

//按照下标相同的位置一次将以上两个数组中的元素插入新的额数组中

//思路：

// 1声明一个新的数组，长度是两个数组长度的和

//2将第一个数组循环赋值给新数组  注意：下标规律为2n

//3将第二个数组循环赋值给新数组，注意：下标规律为2n+1  注意：第二个数组长度如果与第一个数组长度不一致的时候怎么办？

//4当第一个数组复制完成之后第二个数组依次赋值即可

int[ ] arr2 = new int[arr0.lenth + arr1.lenth];

//循环次数为两个数组中长度最大的那个长度

int max = arr0.lenth > arr1.lenth ?  arr0.lenth : arr1.lenth;

//循环次数为两个中最小的那个长度

int min = arr0.lenth < arr1.lenth ?  arr0.lenth : arr1.lenth;

//返回长度最长的那个数组

int maxArray = arr0.lenth < arr1.lenth ?  arr0: arr1.lenth;

for (int i = 0; i <max; i++0){

//获取第一个数组的元素    

//int a = arr0 [ i ];

//获取第二个数组相同下标位置上的元素 

//int b = arr1 [ i ];

if( i < min ){

​    arr2[ 2 * i] = arr0 [i];

​    arr2[2 * i + 1] = arr1[i];

}else{

​    arr2[i + main ]  = maxArray[i]; 

}

}

System.out.println(Arrays.toString(arr2)) ;
```

# 第三方变量实现值的交互

```
@Test

public void test01(){

//需求：将变量a和变量b的值进行值的交互

int a = 10 , b = 20

//思路：使用中间变量  推荐  虽然多使用了变量但是容易理解

int c = a;

​    a = b;

​    b = c;

​    System.out.println("a >>>" + a)) ;

​    System.out.println("b >>>" + b)) ;

}
```

# 第三方变量实现值的交互

```
@Test

public void test02(){

//需求：将变量a和变量b的值进行值的交互   使用三种方式实现

int a = 10 , b = 20

//思路：借助数学公式  但是不推荐   因为数据失真的风险大(因为存储的数据大小不知道，所以有可能超过存储范围)

a = a + b;

b = a - b;

a = a - b;

​    System.out.println("a >>>" + a)) ;

​    System.out.println("b >>>" + b)) ;

} 
```

# 位运算符实现值的交互

```
@Test

public void test02(){

//需求：将变量a和变量b的值进行值的交互   使用三种方式实现

int a = 10 , b = 20

//思路：位运算符  但是不推荐   虽然效率高但是不好理解

a = a ^ b;

b = a ^ b;

a = a ^ b;

​    System.out.println("a >>>" + a)) ;

​    System.out.println("b >>>" + b)) ;

} 

// ^ 亦或是算的内存中的8进制算法得到的数
```

# 数组工具类排序

```
1、在Test测试包中新建一个包  以com开头，的包

2、新建一个类：SortTest  写入方法

3    @Test(导入Test包)

​        public viod test03(){

​        //准备一个数组

​                int[ ] array = {23,32,12,21,19,91};

​                            System.out.println(arrays.toSring(array)) ;

//自带的方法：

​                             Arrays.sort(array);

​                             System.out.println(arrays.toSring(array)) ;

}
```

# 获取数组中最大值或最小值

#### 最大值：

```
@Test

public void test04(){

//需求获取数组中的最大值

int[ ] array = {23,32,12,21,19,91};

//思路：找一个空间变量  将数组中第一位置上的元素存储在该中间变量中  然后依次比较数组中所有元素的值

//获取数组中最后一个元素的值

int max = array [array.length - 1]；

for ( int i = 0; i < array.lengtnh; - 1; i++){

//获取元素的值

​    int j = array [i];

//与中间变量比较，将最大值赋值给中间变量

max = max > j ? max : j ;

}

System.out.println("数组中的最大值 >>>" + max) ;

}
```

#### 最小值：

```
@Test

public void test05(){

//需求获取数组中的最大值

int[ ] array = {23,32,12,21,19,91};

//思路：找一个空间变量  将数组中第一位置上的元素存储在该中间变量中  然后依次比较数组中所有元素的值

//获取数组中最后一个元素的值

int min = array [array.length - 1]；

for ( int i = 0; i < array.lengtnh; - 1; i++){

//获取元素的值

​    int j = array [i];

//与中间变量比较，将最小值赋值给中间变量

min = min < j ? min : j ;

}

System.out.println("数组中的最小值 >>>" + min) ;

}
```

# 数组交换元素

#### 排序(升序)

```
@Test

public void test05(){

//需求：数组升序

int[ ] array = {23,32,12,21,91,19};

for ( int i = 0; i < array.lengtnh; - 1; i++){

//获取元素的值

​    if(array[i] > array [i] ){

​            int temp = array[i];

​            array[i] = array[i + 1];

​            array[i + 1] = temp;

}

}

System.out.println(Arrays.toString(array)) ;

}
```

#### 数组（降序）

```
@Test

public void test05(){

//需求：数组升序

int[ ] array = {23,32,12,21,91,19};

for ( int i = 0; i < array.lengtnh; - 1; i++){

//获取元素的值

​    if(array[i] < array [i] ){

​            int temp = array[i];

​            array[i] = array[i + 1];

​            array[i + 1] = temp;

}

}

System.out.println(Arrays.toString(array)) ;

}
```

# 冒泡排序

只是放的视频

# Arrays.copyOf

### 关于数组的工具类

#### 步骤：

```
1、在test包中建一个Class类  名字是ArraysTest

2、写法：

@Test

public void test01(){

//copyOf(拷贝原数组，新数组的长度，返回的是新数组)就是一个数组的拷贝

​    String[] arr0 = {"一"，“二”，“三”}；

​    System.out.println(Arrays.toString(arr0) );

//使用现在这个数组拷贝成一个新数组   方法：

​    String[] arr1 = Arrays.copyOf(arr0,5);

//使用double类型的  Arrys              new  length是新的数组的意思

​    System.out.pritln(Arrays.toString(arr10));

}

//拷贝以前的元素，生成一个新数组
```

# System.arraycopy

```
@Test

public void test 02(){

​    int[ ] arr0 = {1,2,3,4};

​    int[ ] arr1 = {5,6,7,8};

​    //System.arraycopy(Object src的那个）

​    System.arraycopy(arr0,1,arr1,2,  2）；

//意思是把arr0数组中的1号下标内容替换到 arr1数组中的下标为2的地方截取2个长度

​    System.out.pritln(Arrays.toString(arr1));

}

//这个方法的取值与赋值长度必须一致，保证可以放得下
```

# 多位数组的由来

### 二维数组的声明赋值与读取二位数组中的元素

```
1、声明一个字符串数组

@Test 

public void test 03(){

​    Strring[ ] [ ]   class = {{}，{}，{}}；

//多维数组就像是大包套小包，String后面的中括号就像是包，类似每个子文件 
//等号后面也是一样
//也可以写成这个样子
    Strring[ ] [ ]   class ={
                    {“a”，“b”，“c”}，
                    {“a.1”，“b.1”，“c.1”}，
                    {“a.2”，“b.2”，“c.2”}，
                    }；
System.out.println(classes[0][0]);

}
```

# 遍历二维数组

```
@Test 

public void test 04(){

​    Strring[ ] [ ]   class = {{}，{}，{}}；

//多维数组就像是大包套小包，String后面的中括号就像是包，类似每个子文件 
//等号后面也是一样
//也可以写成这个样子
    Strring[ ] [ ]   class ={
                    {“a”，“b”，“c”}，
                    {“a.1”，“b.1”，“c.1”}，
                    {“a.2”，“b.2”，“c.2”}，
                    }；
    for(int i = 0; i< classes.lenth; i++){
//获取一维数组的元素
        String[] string = classes[i];
        for(int i = 0; i< classes.lenth; i++){
//获取二维数组的元素
            String[] string = string[j];
            System.out.print(“\t”+ string);
        }
        System.out.print("\n");
    }
}
另一种方法：
@Test 
public void test 04(){
​    Strring[ ] [ ]   class = {{}，{}，{}}；
    Strring[ ] [ ]   class ={
                    {“a”，“b”，“c”}，
                    {“a.1”，“b.1”，“c.1”}，
                    {“a.2”，“b.2”，“c.2”}，
                    }；
    for(int i = 0; i< classes[i].lenth; i++){
//获取一维数组的元素
        String[] string = strings[j];
        for(int i = 0; i< classes.lenth; i++){
//获取二维数组的元素
            System.out.print(“\t”+ string[i][j]);
        }
        System.out.print("\n");
    }
}
```

# 二维数组循环赋值

```
@Test 
public void test 05(){
//班级名前缀
    Strring[ ] [ ] coursePreFix = {“java”，“python”，“go”}；
//班级数组
    Strring[ ] [ ]  class = new String[3][20];
    for(int i = 0; i< classes.length; i++){
        String string = classes[i][j];
        if(j < 9 ){
            //string = coursePreFix[i] + "0" + (j + 1) + "\t";
            classes[i][j] = coursePreFix[i] + "0" + (j + 1) + "\t";
            System.out.print(classes[i][j]);
        }else{
            //string = coursePreFix[i] + (j + 1) + "\t";
            classes[i][j] = coursePreFix[i] + (j + 1) + "\t";
            System.out.print(classes[i][j]);
        }
    }
    System.out.println();
    }
}
```

# 随机或中奖者名单

```
@Test 

public void test06(){
    String[] name = new String[15];
    for (int i = 0; i < names.length; i++){
        if (i < 9){
            name[i] = "user" + (i + 1);
        }else{
            name[i] = "user" + (i + 1);
        }
    }
    System.out.println(Arrays.toString(names));
    Random random = new random();
    int luckyIndex = random.nextIN(names.length);
    System.out.println("luckyIndex >>> " + luckyIndex);
    System.out.println("中将人姓名 >>> " + names[luckyIndex]);
}
```

# 随机名字

1、要在pom.xml（最后面的那个文件中）引入依赖

```
                        依赖所有内容

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
  <modelVersion>4.0.0</modelVersion>
  <groupId>com.lihaozhe</groupId>
  <artifactId>day08</artifactId>
  <version>0.0.1-SNAPSHOT</version>
      <dependencies>
        <dependency>
            <groupId>org.junit.jupiter</groupId>
            <artifactId>junit-jupiter</artifactId>
            <version>5.8.2</version>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>com.github.binarywang</groupId>
            <artifactId>java-testdata-generator</artifactId>
            <version>1.1.2</version>
        </dependency>
    </dependencies>
</project>
```

2、找到Maven文件的java -testdata-generator-1.1.2.java

3、打开cn.binarywang的文件从里面打开一个叫ChineseNameGenerator.class的文件中点开一个util包

4、在输入的那个地方输入一个ChineseNameGenerator.getinstance()

这个叫导入，单例模式

5、补全4  

```
@Test
    public void test06( ) {
        ChineseNameGenerator instance = ChineseNameGenerator . getInstance();
        // String name = instance. generate();
        // System. out . print1n(name);
        String[] names = new String[15];
        for (int i = 0; i < names.1ength; i++) {
                    names[i] = instance. generate() ;|
        }
        System. out . print1n(Arrays. toString(names));
        Random random = new Random( ) ;
        int luckyIndex = random . nextInt ( names.1ength);
        System. out . print1n("luckyIndex >>> " + luckyIndex);
        System. out. print1n("中奖人姓名>>> " + names [1uckyIndex]);

}
```

# 利用数组随机姓名

自己做一个姓名

```
@Test
public void test07() {
//姓氏
String[] surnames = new String[] {"东方", "左丘"，"欧阳"，"皇甫"， "上官"，“闾丘"，"令狐"，“夏侯"，"诸葛"，"尉迟"，“皇甫"，"宇文"，"鲜于"，"西门"，"司马"，"独孤"，"公孙"，"慕容"，"轩辕"
};
//名字
String[]
names = new String[] {"何"，"高"，"梁"，"郑"，"罗"，"宋"，"谢","唐"，"韩"，"曹"，"许"，"邓","田"，"沈","陆","石""刘","陈","杨","黄","赵","周",“吴","徐","孙","朱","马","胡","郭","林"
};
Random random = new Random( );
// for (int j = 0; j < 100; j++)}
//随机姓氏
String surname = surnames[random.nextint(surnames.lenth)];
//随机名字
int count = random. nextInt (1,3);
String name =" ";
for(int i = 0; i < count; i++){
        name += names [random. nextInt(names.1ength)];
//拼接姓名
String generateName = surname + name;
System.out.print1n("我的姓名 >>> " + generateName);
}
```

# 可变数组

```
public class Demo03 {
    public static void main(String[] args) {
                int[] array = {1,3,5,7,9};

​                printarray(array);

//如果想传进去一个数组比如3写法就是：printarray(3)；

//但是会报错，在下面那行代码中就要要把int []改成   int ...  

//这个就要可变参数数组，可以是一个值，也可以是多个值

//没有值不会报错，他会认为你传了一个空值进去

//虽然可以传多个数字，但是不能传字符串，因为他的类型就是整数类型，不是字符串类型

​    }
​    public static void printArray(int[] array) {
​                System. out. print("[");

​                for(int i = 0 ; i < array.length; i++){

​                    if(i < array,lenth - 1 ){

​                            System.out print(array[i] + "," );

​                    }else{

​                             System.out print(array[i] );

​                    }

​                System. out . println("] ");

​    }

}

```