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    
View Code

 

   

补充:利用随机数,填充数组(涉及 随机数的获取方法)

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

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

 

posted @ 2019-08-22 20:30 小喵钓鱼 阅读(...) 评论(...) 编辑 收藏