Java学习笔记（四）

本篇概述==>

　　　　数组（依旧只叙述与C++不同的地方，或者一些应用方法例子，毕竟语言是共通的，多了也是废话.jpg）

一，如果创建一维数组，二维数组，以及 N维数组（以此类推）呢 =-=

// 一维数组创建方法
int [] list = new int[];

// 一维数组初始化方法
int a[] = new int[]{1, 2, 3}; 

// 二维数组创建方法
int [][] list = new int[n][];  // 一维上必须标明长度，和C++语法一样

// 二维数组初始化方法
int a[][] = new int [][]{
                {1, 2, 3},
                {2, 3, 4}
}

 二，数组的一些方法（排序，复制.......）

　1. 增强型 For 循环

　　用来取值，不能修改数组里的值，相当于 普通 for 循环取值的 简便方法

// 增强型for循环只能用来取值，不能用来修改数组里的值
int values [] = new int[]{18,62,68,82,65,9};
// 增强
int temp = values[0];
for (int each : values)
{
    if (temp < each)
        temp = each;
}
System.out.println("最大:" + temp);

 　2. 数组的复制

　　一个数组的长度是不可变的，一旦分配好空间，是多长就多长，不能改变

　　而把一个数组的值，复制到另外一个数组上去，相对简单的方法就是通过System.arraycopy() 方法　　

　　如果是通过 for 循环一个个进行赋值不免繁琐了点 =-=，下面是通过该方法的代码示例

int a [] = new int[]{18,62,68,82,65,9};
int b[] = new int[3];//分配了长度是3的空间，但是没有赋值
//通过数组赋值把，a数组的前3位赋值到b数组
// System.arraycopy(src, srcPos, dest, desPos, length)
// src 源数组
// srcPos 从源数组复制数据的起始位置
// dest 目标数组
// destPos 复制目标数组的启始位置
// 复制的长度
System.arraycopy(a, 0, b, 0, 3);

　　还有一个相对这个方法参数更少的方法，就是利用 Arrays工具的 copyOfRange() 方法

import java.util.Arrays;
 
public class HelloWorld {
    public static void main(String[] args) {
        int a[] = new int[] { 18, 62, 68, 82, 65, 9 };
 
        // copyOfRange(int[] original, int from, int to)
        // 第一个参数表示源数组
        // 第二个参数表示开始位置(取得到)
        // 第三个参数表示结束位置(取不到)
        int[] b = Arrays.copyOfRange(a, 0, 3);
 
        for (int i = 0; i < b.length; i++) {
            System.out.print(b[i] + " ");
        }
 
    }
}

　3. 数组的排序

　　3.1 非方法，通过 for 循环来进行繁琐排序（涉及 选择法 和 冒泡法 ，C++中有讲）

　　　直白点说，选择法就是每一次for循环，通过一个和全部比较，将最小的那只放数组前面，以此类推，从小到大

　　　　　　　　冒泡法就是每一次for循环，通过左右两边比较，将最大的一点点往后面移，从而达到从小到大的效果

　　　以下是一个两个方法结合的例子（~~）

// 冒泡和 选择  倒序 正序  四合一
import java.util.Scanner;
public class Twenty_Three_sort {
    public static void main(String[] args) {
        System.out.println("请输入该数组的长度");
        Scanner scanner = new Scanner(System.in);
        int n = scanner.nextInt();
        int [] list = new int[n];
        for (int i = 0; i < list.length; i++)
        {
            list[i] = (int)(Math.random()*100);
            System.out.println("list["+ i +"] = " + list[i]);
        }
        System.out.println("请选择排序方式（倒序/正序）");
        String tab = scanner.nextLine();
        String select = scanner.nextLine();
        switch(select)
        {
            case "倒序":{
                System.out.println("请选择排序方法（冒泡法 / 选择法）:");
                String option = scanner.nextLine();
                switch (option){
                    case "选择法":
                    {
                        for (int i = 0; i < list.length - 1; i++)
                        {
                            for (int j = i + 1; j < list.length; j++)
                            {
                                if (list[j] > list[i])
                                {
                                    int temp = list[i];
                                    list[i] = list[j];
                                    list[j] = temp;
                                }
                            }
                        }
                        break;
                    }
                    case "冒泡法":
                    {
                        for (int i = 0; i < list.length; i++)
                        {
                            for (int j = 0; j < list.length - i -1; j++) {
                                if (list[j] < list[j+1])
                                {
                                    int temp = list[j+1];
                                    list[j+1] = list[j];
                                    list[j] = temp;
                                }
                            }
                        }
                        break;
                    }
                }
                break;
            }
            case "正序": {
                System.out.println("请选择排序方法（冒泡法 / 选择法）:");
                String option = scanner.nextLine();
                switch (option){
                    case "选择法":
                    {
                        for (int i = 0; i < list.length - 1; i++)
                        {
                            for (int j = i + 1; j < list.length; j++)
                            {
                                if (list[j] < list[i])
                                {
                                    int temp = list[i];
                                    list[i] = list[j];
                                    list[j] = temp;
                                }
                            }
                        }
                        break;
                    }
                    case "冒泡法":
                    {
                        for (int i = 0; i < list.length; i++)
                        {
                            for (int j = 0; j < list.length - i -1; j++) {
                                if (list[j] > list[j+1])
                                {
                                    int temp = list[j+1];
                                    list[j+1] = list[j];
                                    list[j] = temp;
                                }
                            }
                        }
                        break;
                    }
                }
                break;
            }
        }
        System.out.println("-------------------------------------");
        for (int i = 0; i < list.length; i++)
        {
            System.out.println("list["+ i +"] = " + list[i]);
        }
    }
}

　　3.2 方法

　　　利用 Arrays.sort() 方法 一步到位

int a[] = new int[] { 18, 62, 68, 82, 65, 9 };
Arrays.sort(a)

　　3.3 转换为字符串

　　　利用 Arrays.toString()方法 

int []b = Arrays.copyOfRange(a, 0, 3);
// 转换为字符串
//是Arrays提供了一个toString()方法，直接把一个数组，转换为字符串，这样方便观察数组的内容
 String content = Arrays.toString(a);

　　3.4 搜索

　　　查询元素出现的位置，需要注意的是，使用binarySearch进行查找之前，必须使用sort进行排序
如果数组中有多个相同的元素，查找结果是不确定的

System.out.println("62出现的位置" + Arrays.binarySearch(a, 62));

　　3.5 判断两个数组的内容是否相同（返回 bolean类型）

// 比较两个数组的元素是否相同
Arrays.equals(a, b);

　　3.6 填充数组

　　　使用同一个值，填充整个数组

int a[] = new int[10];
  
Arrays.fill(a, 5);

　　一个例子，将二维数组排序

import java.util.Arrays;
import java.util.Scanner;
public class Thirty_pratice_sort_double_dimensional_Array {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入二维数组的行数: ");
        int n1 = scanner.nextInt();
        System.out.println("请输入二维数组的列数: ");
        int n2 = scanner.nextInt();
        int[][] a = new int[n1][n2];
        for (int i = 0; i < n1; i++)
        {
            for (int j = 0; j < n2; j++)
            {
                a[i][j] = (int)(Math.random()*100);
                System.out.print("	 a["+i+"]["+j+"] = "+a[i][j] + "	");
            }
            System.out.print("
");
        }
        int [] array = new int[n1*n2];
        for (int i = 0; i < a.length; i++)
        {
            System.arraycopy(a[i], 0, array, a[i].length*i, a[i].length);  // 将二维数组复制到一维数组上
        }
        Arrays.sort(array);
        for (int i = 0; i < a.length; i++)
        {
            System.arraycopy(array, a.length*i, a[i], 0, a[i].length);  // 将一维数组还原到二维数组上
        }

        System.out.println("排序后：");
        for (int i = 0; i < n1; i++)
        {
            for (int j = 0; j < n2; j++)
            {
                System.out.print("	 a["+i+"]["+j+"] = "+a[i][j] + "	");
            }
            System.out.print("
");
        }
    }
}

// 结果
请输入二维数组的行数: 
5
请输入二维数组的列数: 
6
     a[0][0] = 50         a[0][1] = 42         a[0][2] = 94         a[0][3] = 65         a[0][4] = 31         a[0][5] = 28    
     a[1][0] = 95         a[1][1] = 37         a[1][2] = 59         a[1][3] = 82         a[1][4] = 85         a[1][5] = 34    
     a[2][0] = 30         a[2][1] = 2         a[2][2] = 63         a[2][3] = 83         a[2][4] = 99         a[2][5] = 64    
     a[3][0] = 31         a[3][1] = 56         a[3][2] = 56         a[3][3] = 4         a[3][4] = 4         a[3][5] = 3    
     a[4][0] = 99         a[4][1] = 61         a[4][2] = 83         a[4][3] = 13         a[4][4] = 94         a[4][5] = 41    
排序后：
     a[0][0] = 2         a[0][1] = 3         a[0][2] = 4         a[0][3] = 4         a[0][4] = 13         a[0][5] = 28    
     a[1][0] = 28         a[1][1] = 30         a[1][2] = 31         a[1][3] = 31         a[1][4] = 34         a[1][5] = 37    
     a[2][0] = 37         a[2][1] = 41         a[2][2] = 42         a[2][3] = 50         a[2][4] = 56         a[2][5] = 56    
     a[3][0] = 56         a[3][1] = 59         a[3][2] = 61         a[3][3] = 63         a[3][4] = 64         a[3][5] = 65    
     a[4][0] = 65         a[4][1] = 82         a[4][2] = 83         a[4][3] = 83         a[4][4] = 85         a[4][5] = 94    
请输入二维数组的行数: 
5
请输入二维数组的列数: 
6
     a[0][0] = 50         a[0][1] = 42         a[0][2] = 94         a[0][3] = 65         a[0][4] = 31         a[0][5] = 28    
     a[1][0] = 95         a[1][1] = 37         a[1][2] = 59         a[1][3] = 82         a[1][4] = 85         a[1][5] = 34    
     a[2][0] = 30         a[2][1] = 2         a[2][2] = 63         a[2][3] = 83         a[2][4] = 99         a[2][5] = 64    
     a[3][0] = 31         a[3][1] = 56         a[3][2] = 56         a[3][3] = 4         a[3][4] = 4         a[3][5] = 3    
     a[4][0] = 99         a[4][1] = 61         a[4][2] = 83         a[4][3] = 13         a[4][4] = 94         a[4][5] = 41    
排序后：
     a[0][0] = 2         a[0][1] = 3         a[0][2] = 4         a[0][3] = 4         a[0][4] = 13         a[0][5] = 28    
     a[1][0] = 28         a[1][1] = 30         a[1][2] = 31         a[1][3] = 31         a[1][4] = 34         a[1][5] = 37    
     a[2][0] = 37         a[2][1] = 41         a[2][2] = 42         a[2][3] = 50         a[2][4] = 56         a[2][5] = 56    
     a[3][0] = 56         a[3][1] = 59         a[3][2] = 61         a[3][3] = 63         a[3][4] = 64         a[3][5] = 65    
     a[4][0] = 65         a[4][1] = 82         a[4][2] = 83         a[4][3] = 83         a[4][4] = 85         a[4][5] = 94    

　　　

补充：利用随机数，填充数组（涉及 随机数的获取方法）

　Math.random() 方法只能获取 0~1之间的随机值，则为了 获取 0 - 100 之间的整数，其方法为

int n = (int)(Math.random()*100);