Java学习笔记（四）

2019-08-26 06:24:43来源：博客园阅读 ()

Java学习笔记（四）

本篇概述==>

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

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

 1 // 一维数组创建方法
 2 int [] list = new int[];
 3 
 4 // 一维数组初始化方法
 5 int a[] = new int[]{1, 2, 3}; 
 6 
 7 // 二维数组创建方法
 8 int [][] list = new int[n][];  // 一维上必须标明长度，和C++语法一样
 9 
10 // 二维数组初始化方法
11 int a[][] = new int [][]{
12                 {1, 2, 3},
13                 {2, 3, 4}
14 }

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

　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 循环一个个进行赋值不免繁琐了点 =-=，下面是通过该方法的代码示例

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

View Code

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

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

View Code

　3. 数组的排序

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

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

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

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

  1 // 冒泡和 选择  倒序 正序  四合一
  2 import java.util.Scanner;
  3 public class Twenty_Three_sort {
  4     public static void main(String[] args) {
  5         System.out.println("请输入该数组的长度");
  6         Scanner scanner = new Scanner(System.in);
  7         int n = scanner.nextInt();
  8         int [] list = new int[n];
  9         for (int i = 0; i < list.length; i++)
 10         {
 11             list[i] = (int)(Math.random()*100);
 12             System.out.println("list["+ i +"] = " + list[i]);
 13         }
 14         System.out.println("请选择排序方式（倒序/正序）");
 15         String tab = scanner.nextLine();
 16         String select = scanner.nextLine();
 17         switch(select)
 18         {
 19             case "倒序":{
 20                 System.out.println("请选择排序方法（冒泡法 / 选择法）:");
 21                 String option = scanner.nextLine();
 22                 switch (option){
 23                     case "选择法":
 24                     {
 25                         for (int i = 0; i < list.length - 1; i++)
 26                         {
 27                             for (int j = i + 1; j < list.length; j++)
 28                             {
 29                                 if (list[j] > list[i])
 30                                 {
 31                                     int temp = list[i];
 32                                     list[i] = list[j];
 33                                     list[j] = temp;
 34                                 }
 35                             }
 36                         }
 37                         break;
 38                     }
 39                     case "冒泡法":
 40                     {
 41                         for (int i = 0; i < list.length; i++)
 42                         {
 43                             for (int j = 0; j < list.length - i -1; j++) {
 44                                 if (list[j] < list[j+1])
 45                                 {
 46                                     int temp = list[j+1];
 47                                     list[j+1] = list[j];
 48                                     list[j] = temp;
 49                                 }
 50                             }
 51                         }
 52                         break;
 53                     }
 54                 }
 55                 break;
 56             }
 57             case "正序": {
 58                 System.out.println("请选择排序方法（冒泡法 / 选择法）:");
 59                 String option = scanner.nextLine();
 60                 switch (option){
 61                     case "选择法":
 62                     {
 63                         for (int i = 0; i < list.length - 1; i++)
 64                         {
 65                             for (int j = i + 1; j < list.length; j++)
 66                             {
 67                                 if (list[j] < list[i])
 68                                 {
 69                                     int temp = list[i];
 70                                     list[i] = list[j];
 71                                     list[j] = temp;
 72                                 }
 73                             }
 74                         }
 75                         break;
 76                     }
 77                     case "冒泡法":
 78                     {
 79                         for (int i = 0; i < list.length; i++)
 80                         {
 81                             for (int j = 0; j < list.length - i -1; j++) {
 82                                 if (list[j] > list[j+1])
 83                                 {
 84                                     int temp = list[j+1];
 85                                     list[j+1] = list[j];
 86                                     list[j] = temp;
 87                                 }
 88                             }
 89                         }
 90                         break;
 91                     }
 92                 }
 93                 break;
 94             }
 95         }
 96         System.out.println("-------------------------------------");
 97         for (int i = 0; i < list.length; i++)
 98         {
 99             System.out.println("list["+ i +"] = " + list[i]);
100         }
101     }
102 }

View Code

　　3.2 方法

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

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

　　3.3 转换为字符串

　　　利用 Arrays.toString()方法

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

　　3.4 搜索

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

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

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

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

　　3.6 填充数组

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

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

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

 1 import java.util.Arrays;
 2 import java.util.Scanner;
 3 public class Thirty_pratice_sort_double_dimensional_Array {
 4     public static void main(String[] args) {
 5         Scanner scanner = new Scanner(System.in);
 6         System.out.println("请输入二维数组的行数: ");
 7         int n1 = scanner.nextInt();
 8         System.out.println("请输入二维数组的列数: ");
 9         int n2 = scanner.nextInt();
10         int[][] a = new int[n1][n2];
11         for (int i = 0; i < n1; i++)
12         {
13             for (int j = 0; j < n2; j++)
14             {
15                 a[i][j] = (int)(Math.random()*100);
16                 System.out.print("\t a["+i+"]["+j+"] = "+a[i][j] + "\t");
17             }
18             System.out.print("\n");
19         }
20         int [] array = new int[n1*n2];
21         for (int i = 0; i < a.length; i++)
22         {
23             System.arraycopy(a[i], 0, array, a[i].length*i, a[i].length);  // 将二维数组复制到一维数组上
24         }
25         Arrays.sort(array);
26         for (int i = 0; i < a.length; i++)
27         {
28             System.arraycopy(array, a.length*i, a[i], 0, a[i].length);  // 将一维数组还原到二维数组上
29         }
30 
31         System.out.println("排序后：");
32         for (int i = 0; i < n1; i++)
33         {
34             for (int j = 0; j < n2; j++)
35             {
36                 System.out.print("\t a["+i+"]["+j+"] = "+a[i][j] + "\t");
37             }
38             System.out.print("\n");
39         }
40     }
41 }
42 
43 // 结果
44 请输入二维数组的行数: 
45 5
46 请输入二维数组的列数: 
47 6
48      a[0][0] = 50         a[0][1] = 42         a[0][2] = 94         a[0][3] = 65         a[0][4] = 31         a[0][5] = 28    
49      a[1][0] = 95         a[1][1] = 37         a[1][2] = 59         a[1][3] = 82         a[1][4] = 85         a[1][5] = 34    
50      a[2][0] = 30         a[2][1] = 2         a[2][2] = 63         a[2][3] = 83         a[2][4] = 99         a[2][5] = 64    
51      a[3][0] = 31         a[3][1] = 56         a[3][2] = 56         a[3][3] = 4         a[3][4] = 4         a[3][5] = 3    
52      a[4][0] = 99         a[4][1] = 61         a[4][2] = 83         a[4][3] = 13         a[4][4] = 94         a[4][5] = 41    
53 排序后：
54      a[0][0] = 2         a[0][1] = 3         a[0][2] = 4         a[0][3] = 4         a[0][4] = 13         a[0][5] = 28    
55      a[1][0] = 28         a[1][1] = 30         a[1][2] = 31         a[1][3] = 31         a[1][4] = 34         a[1][5] = 37    
56      a[2][0] = 37         a[2][1] = 41         a[2][2] = 42         a[2][3] = 50         a[2][4] = 56         a[2][5] = 56    
57      a[3][0] = 56         a[3][1] = 59         a[3][2] = 61         a[3][3] = 63         a[3][4] = 64         a[3][5] = 65    
58      a[4][0] = 65         a[4][1] = 82         a[4][2] = 83         a[4][3] = 83         a[4][4] = 85         a[4][5] = 94    
59 请输入二维数组的行数: 
60 5
61 请输入二维数组的列数: 
62 6
63      a[0][0] = 50         a[0][1] = 42         a[0][2] = 94         a[0][3] = 65         a[0][4] = 31         a[0][5] = 28    
64      a[1][0] = 95         a[1][1] = 37         a[1][2] = 59         a[1][3] = 82         a[1][4] = 85         a[1][5] = 34    
65      a[2][0] = 30         a[2][1] = 2         a[2][2] = 63         a[2][3] = 83         a[2][4] = 99         a[2][5] = 64    
66      a[3][0] = 31         a[3][1] = 56         a[3][2] = 56         a[3][3] = 4         a[3][4] = 4         a[3][5] = 3    
67      a[4][0] = 99         a[4][1] = 61         a[4][2] = 83         a[4][3] = 13         a[4][4] = 94         a[4][5] = 41    
68 排序后：
69      a[0][0] = 2         a[0][1] = 3         a[0][2] = 4         a[0][3] = 4         a[0][4] = 13         a[0][5] = 28    
70      a[1][0] = 28         a[1][1] = 30         a[1][2] = 31         a[1][3] = 31         a[1][4] = 34         a[1][5] = 37    
71      a[2][0] = 37         a[2][1] = 41         a[2][2] = 42         a[2][3] = 50         a[2][4] = 56         a[2][5] = 56    
72      a[3][0] = 56         a[3][1] = 59         a[3][2] = 61         a[3][3] = 63         a[3][4] = 64         a[3][5] = 65    
73      a[4][0] = 65         a[4][1] = 82         a[4][2] = 83         a[4][3] = 83         a[4][4] = 85         a[4][5] = 94