Java學習筆記(四)

来源:https://www.cnblogs.com/xmdykf/archive/2019/08/22/11396523.html
-Advertisement-
Play Games

本篇概述==> 數組(依舊只敘述與C++不同的地方,或者一些應用方法例子,畢竟語言是共通的,多了也是廢話.jpg) 一,如果創建一維數組,二維數組,以及 N維數組(以此類推)呢 二,數組的一些方法(排序,複製.......) 1. 增強型 For 迴圈 用來取值,不能修改數組裡的值,相當於 普通 f ...


本篇概述==>

    數組(依舊只敘述與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);

 


您的分享是我們最大的動力!

-Advertisement-
Play Games
更多相關文章
  • 摘要: 的兩大核心技術就是 和`AOP AOP Spring AOP CGLIB Spring AOP Spring AOP`的一個運行過程。知其然,知其所以然,才能更好的駕馭這門核心技術。 所有的 驅動技術都得看他的 ,所以上面最重要的是這一句 ,下麵看看它 是一個項容器註冊自動代理創建器 說明 ...
  • 對於剛入門的springboot的新手來說,學的過程中碰到的一些問題記錄下。 1. 首先,配置好Maven環境及本地倉庫 之後進入Maven安裝目錄conf文件夾下的settings.xml配置文件,用Notepadd++打開文件。 配置本地倉庫指向自己創建的本地倉庫,如圖 把jdk版本固定為1.8 ...
  • 對Series的理解也源於對其相關的代碼操作,本次僅貼一些代碼來加深理解以及記憶 ...
  • 第十二章 Django框架 12.1 伺服器程式和應用程式 伺服器程式負責對socket伺服器進行封裝,併在請求到來時,對請求的各種數據進行整理。應用程式則負責具體的邏輯處理。為了方便應用程式的開發,就出現了眾多的Web框架,例如:Django、Flask、web.py 等。不同的框架有不同的開發方 ...
  • 一、使用JSONObject來解析JSON數據官方提供的,所以不需要導入第三方jar包;直接上代碼,如下 步驟解讀: 定義一個JSON數組,用於將伺服器返回的數據傳入到一個JSONArray對象中; 然後迴圈遍歷這個JSONArray,從中取出每一個元素(JSONObject對象),接下來只需調用g ...
  • String轉成jsonObject JsonObject json = JsonObject.fromObject(String str) String轉成JsonArray JsonArray jsonArray = JsonArray.fromObject(String str) 在開發過程中 ...
  • Spring Security 解析(二) —— 認證過程   在學習Spring Cloud 時,遇到了授權服務oauth 相關內容時,總是一知半解,因此決定先把Spring Security 、Spring Security Oauth2 等許可權、認證相關的內容、原理及設計學 ...
  • 一、概述 1. 什麼是代理 我們大家都知道微商代理,簡單地說就是代替廠家賣商品,廠家“委托”代理為其銷售商品。關於微商代理,首先我們從他們那裡買東西時通常不知道背後的廠家究竟是誰,也就是說,“委托者”對我們來說是不可見的;其次,微商代理主要以朋友圈的人為目標客戶,這就相當於為廠家做了一次對客戶群體的 ...
一周排行
    -Advertisement-
    Play Games
  • Dapr Outbox 是1.12中的功能。 本文只介紹Dapr Outbox 執行流程,Dapr Outbox基本用法請閱讀官方文檔 。本文中appID=order-processor,topic=orders 本文前提知識:熟悉Dapr狀態管理、Dapr發佈訂閱和Outbox 模式。 Outbo ...
  • 引言 在前幾章我們深度講解了單元測試和集成測試的基礎知識,這一章我們來講解一下代碼覆蓋率,代碼覆蓋率是單元測試運行的度量值,覆蓋率通常以百分比表示,用於衡量代碼被測試覆蓋的程度,幫助開發人員評估測試用例的質量和代碼的健壯性。常見的覆蓋率包括語句覆蓋率(Line Coverage)、分支覆蓋率(Bra ...
  • 前言 本文介紹瞭如何使用S7.NET庫實現對西門子PLC DB塊數據的讀寫,記錄了使用電腦模擬,模擬PLC,自至完成測試的詳細流程,並重點介紹了在這個過程中的易錯點,供參考。 用到的軟體: 1.Windows環境下鏈路層網路訪問的行業標準工具(WinPcap_4_1_3.exe)下載鏈接:http ...
  • 從依賴倒置原則(Dependency Inversion Principle, DIP)到控制反轉(Inversion of Control, IoC)再到依賴註入(Dependency Injection, DI)的演進過程,我們可以理解為一種逐步抽象和解耦的設計思想。這種思想在C#等面向對象的編 ...
  • 關於Python中的私有屬性和私有方法 Python對於類的成員沒有嚴格的訪問控制限制,這與其他面相對對象語言有區別。關於私有屬性和私有方法,有如下要點: 1、通常我們約定,兩個下劃線開頭的屬性是私有的(private)。其他為公共的(public); 2、類內部可以訪問私有屬性(方法); 3、類外 ...
  • C++ 訪問說明符 訪問說明符是 C++ 中控制類成員(屬性和方法)可訪問性的關鍵字。它們用於封裝類數據並保護其免受意外修改或濫用。 三種訪問說明符: public:允許從類外部的任何地方訪問成員。 private:僅允許在類內部訪問成員。 protected:允許在類內部及其派生類中訪問成員。 示 ...
  • 寫這個隨筆說一下C++的static_cast和dynamic_cast用在子類與父類的指針轉換時的一些事宜。首先,【static_cast,dynamic_cast】【父類指針,子類指針】,兩兩一組,共有4種組合:用 static_cast 父類轉子類、用 static_cast 子類轉父類、使用 ...
  • /******************************************************************************************************** * * * 設計雙向鏈表的介面 * * * * Copyright (c) 2023-2 ...
  • 相信接觸過spring做開發的小伙伴們一定使用過@ComponentScan註解 @ComponentScan("com.wangm.lifecycle") public class AppConfig { } @ComponentScan指定basePackage,將包下的類按照一定規則註冊成Be ...
  • 操作系統 :CentOS 7.6_x64 opensips版本: 2.4.9 python版本:2.7.5 python作為腳本語言,使用起來很方便,查了下opensips的文檔,支持使用python腳本寫邏輯代碼。今天整理下CentOS7環境下opensips2.4.9的python模塊筆記及使用 ...