溫馨提示×
您好，登錄后才能下訂單哦！
點擊 登錄注冊 即表示同意《億速云用戶服務條款》
您好，登錄后才能下訂單哦！
本文實例講述了Java基礎學習筆記之數組。分享給大家供大家參考，具體如下：
數組的定義于使用
1：數組的基本概念
一組相關變量的集合；在Java里面將數組定義為引用數據類型，所以數組的使用一定要牽扯到內存分配；想到了用new 關鍵字來處理。
2：數組的定義格式
區別：
動態初始化后數組中的每一個元素的內容都是其對應數據類型的默認值，隨后可以通過下標進行數組內容的修改；
如果希望數組定義的時候就可以提供內容，則采用靜態初始化的方式；
a：數組的動態初始化（聲明并初始化數組）：
數據類型 數組名稱 【】 = new 數據類型 【長度】；
數據類型 【】 數組名稱 = new 數據類型 【長度】
b：數組的靜態初始化（在數組定義的時候就為其設置好了里面的內容）
簡化格式：數據類型 數組 數組名稱 【】 = {數據1，數據2，數據3，。。。}；
完整格式：數據類型 數組名稱【】 = new 數據類型【】{ 數據1，數據2，數據3，。。。}；
3：數組的特點
通過腳標訪問：0~n-1；
進行數組操作的時候往往會利用for循環來完成；
數組的長度：“數組名稱.length”；
4：數組的引用傳遞
數組定義時用到了new，所以這里存在有內存關系匹配。
public class ArrayDemo {
public static void main(String args[]) {
// 使用數組的靜態初始化
int data [] = new int [3] ;
data [0] = 10 ; // 為數組設置內容
data [1] = 20 ; // 為數組設置內容
data [2] = 30 ; // 為數組設置內容
for (int x = 0 ; x < data.length ; x ++) {
System.out.println(data[x]) ;
}
}
}
一個堆內存可以被多個棧內存所指向
public class ArrayDemo {
public static void main(String args[]) {
int data [] = new int [] {10,20,30} ; // 靜態初始化
int temp [] = data ; // 引用傳遞
temp [0] = 99 ;
for (int x = 0 ; x < data.length ; x ++) {
System.out.println(data[x]) ;
}
}
}
由于數組是引用數據類型，所以一定要為其開辟堆內存空間（也就是實例化對象）才可以使用，如果使用了未開辟堆內存空間的數組則一定會出現“NullPointerException”異常
5foreach迭代輸出
JDK1.5之后為了減輕下標對程序的影響（以為下標處理不當則會出現數組越界異常），參考了.NET的設計，引入了增強型for循環：foreach
for(數據類型 變量 ：數組名) { }
特點：可以自動將數組中的每一個元素的內容取出保存到變量里，這樣就可以直接通過變量獲取數組的內容，避免了數組越界。
public class ArrayDemo {
public static void main(String args[]) {
int data [] = new int [] {1,2,3,4,5} ;
for (int temp : data) { // 自動循環，將data數組每一個內容交給temp
System.out.println(temp) ;
}
}
}
6：二維數組
定義格式：
a：動態初始化：數據類型 數組名稱【】【】 = new 數據類型【行個數】【列個數】；
b：靜態初始化：數據類型 【】【】 new 數據類型 【】【】 { { 數據，數據 …}，{ 數據，數據…}，… }
public class ArrayDemo {
public static void main(String args[]) {
int data [][] = new int [][] {
{1,2,3,4,5} , {1,2,3} , {5,6,7,8}} ;
for (int x = 0 ; x < data.length ; x ++) {
for (int y = 0 ; y < data[x].length ; y ++) {
System.out.println("data["+x+"]["+y+"] = " + data[x][y]) ;
}
System.out.println() ; // 換行
}
}
}
//輸出結果：
data[0][0] = 1
data[0][1] = 2
data[0][2] = 3
data[0][3] = 4
data[0][4] = 5
data[1][0] = 1
data[1][1] = 2
data[1][2] = 3
data[2][0] = 5
data[2][1] = 6
data[2][2] = 7
data[2][3] = 8
同一個二維數組通過foreach輸出
public class ArrayDemo {
public static void main(String args[]) {
int data [][] = new int [][] {
{1,2,3,4,5} , {1,2,3} , {5,6,7,8}} ;
for (int temp [] : data) {
for (int num : temp) {
System.out.print(num + "、") ;
}
System.out.println() ;
}
}
}
//輸出結果
1、2、3、4、5、
1、2、3、
5、6、7、8
7數組與方法
對于引用數據類型，主要的特點是可以于方法進行引用傳遞，數組本身也是引用數據類型，所以自然也可以通過方法實現引用傳遞的操作。
public class ArrayDemo {
public static void main(String args[]) {
int data [] = new int [] {1,2,3,4,5} ;
printArray(data) ; // 傳遞數組
}
// 要求接收一個int型的數組
public static void printArray(int temp []) {
for (int x = 0 ; x < temp.length ; x ++) {
System.out.println(temp[x]) ;
}
}
}
//通過方法來接收一個數組
public class ArrayDemo {
public static void main(String args[]) {
int data [] = initArray() ; // 通過方法可以獲得數組內容
printArray(data) ; // 傳遞數組
}
public static int [] initArray() {
int arr [] = new int [] {1,2,3,4,5} ;
return arr ; // 返回一個數組
}
// 要求接收一個int型的數組
public static void printArray(int temp []) {
for (int x = 0 ; x < temp.length ; x ++) {
System.out.println(temp[x]) ;
}
}
}
//通過方法返回一個數組對象
public class ArrayDemo {
public static void main(String args[]) {
int data [] = new int [] {1,2,3,4,5} ;
changeArray(data) ; // 修改數組內容
printArray(data) ; // 傳遞數組
}
public static void changeArray(int arr[]) {
for (int x = 0 ; x < arr.length ; x ++) {
arr[x] *= 2 ; // 每個元素的內容乘2保存
}
}
// 要求接收一個int型的數組
public static void printArray(int temp []) {
for (int x = 0 ; x < temp.length ; x ++) {
System.out.println(temp[x]) ;
}
}
}
//通過方法修改數組內容。
下面寫一個案例，總結上面內容
案例;定義一個int數組，要求計算出這個數組元素的總和，最大值，最小值，平均值。
//此程序的基本實現
public class ArrayDemo {
public static void main(String args[]) {
int data [] = new int [] {1,2,3,4,5} ;
int sum = 0 ; ;
double avg = 0.0 ;
int max = data[0] ; // 假設第一個是最大值
int min = data[0] ; // 假設第一個是最小值
for (int x = 0 ; x < data.length ; x ++) {
if (data[x] > max) { // max地位改變了
max = data[x] ;
}
if (data[x] < min) {
min = data[x] ;
}
sum += data[x] ;
}
avg = sum / data.length ;
System.out.println("數組內容總和：" + sum) ;
System.out.println("數組內容平均值：" + avg) ;
System.out.println("數組內容最大值：" + max) ;
System.out.println("數組內容最小值：" + min) ;
}
public static void printArray(int temp []) {
for (int x = 0 ; x < temp.length ; x ++) {
System.out.println(temp[x]) ;
}
}
}
問題：主函數所在的類往往被稱為主類，那么既然是主類中不希望涉及過多復雜的功能；在開發的過程中，主方法本身就相當于是一個客戶端，而對于客戶端的代碼盡量簡單一些，所以這個時候是將一系列的計算過程交給單獨的程序類去完成。
//改善操作設計
class ArrayUtil { // 是一個操作工具的類
private int sum ; // 保存總和
private double avg ; // 保存平均值
private int max ; // 保存最大值
private int min ; // 保存最小值
public ArrayUtil(int data[]) { // 進行數組計算
this.max = data[0] ; // 假設第一個是最大值
this.min = data[0] ; // 假設第一個是最小值
for (int x = 0 ; x < data.length ; x ++) {
if (data[x] > max) { // max地位改變了
this.max = data[x] ;
}
if (data[x] < min) {
this.min = data[x] ;
}
this.sum += data[x] ;
}
this.avg = this.sum / data.length ;
}
public int getSum() {
return this.sum ;
}
public double getAvg() {
return this.avg ;
}
public int getMax() {
return this.max ;
}
public int getMin() {
return this.min ;
}
}
public class ArrayDemo {
public static void main(String args[]) {
int data [] = new int [] {1,2,3,4,5} ;
ArrayUtil util = new ArrayUtil(data) ; // 數據計算
System.out.println("數組內容總和：" + util.getSum()) ;
System.out.println("數組內容平均值：" + util.getAvg()) ;
System.out.println("數組內容最大值：" + util.getMax()) ;
System.out.println("數組內容最小值：" + util.getMin()) ;
}
}
8：數組操作案例：數組反轉
做法一：定義一個新的數組而后按照逆序的方式保存（會產生無用的垃圾空間）
class ArrayUtil {
public static void printArray(int temp []) {
for (int x = 0 ; x < temp.length ; x ++) {
System.out.print(temp[x] + "、") ;
}
System.out.println() ;
}
}
public class ArrayDemo {
public static void main(String args[]) {
int data [] = new int [] {1,2,3,4,5,6,7,8,9} ;
int temp [] = new int [data.length] ; // 第二個數組
int foot = temp.length - 1; // 第二個數組的腳標
for (int x = 0 ; x < data.length ; x ++) {
temp[foot --] = data[x] ;
}
data = temp ;
ArrayUtil.printArray(data) ;
}
}
做法二：在一個數組上進行轉置
class ArrayUtil {
public static void printArray(int temp []) {
for (int x = 0 ; x < temp.length ; x ++) {
System.out.print(temp[x] + "、") ;
}
System.out.println() ;
}
}
public class ArrayDemo {
public static void main(String args[]) {
int data [] = new int [] {1,2,3,4,5,6,7,8,9} ;
int center = data.length / 2 ; // 確定轉換的次數
int head = 0 ; // 操作腳標
int tail = data.length - 1 ; // 操作腳標
for (int x = 0 ; x < center ; x ++) {
int temp = data [head] ;
data [head] = data [tail] ;
data [tail] = temp ;
head ++ ;
tail -- ;
}
ArrayUtil.printArray(data) ;
}
}
比較兩種方式：第一種循環次數較多，會產生垃圾；第二種實現循環次數較低，但是存在if判斷增加了
時間復雜度，可是減少了無用對象的產生，提升了性能。
//將轉換功能變為類定義
class ArrayUtil {
public static void reverse(int data[]) {
int center = data.length / 2 ; // 確定轉換的次數
int head = 0 ; // 操作腳標
int tail = data.length - 1 ; // 操作腳標
for (int x = 0 ; x < center ; x ++) {
int temp = data [head] ;
data [head] = data [tail] ;
data [tail] = temp ;
head ++ ;
tail -- ;
}
}
public static void printArray(int temp []) {
for (int x = 0 ; x < temp.length ; x ++) {
System.out.print(temp[x] + "、") ;
}
System.out.println() ;
}
}
public class ArrayDemo {
public static void main(String args[]) {
int data [] = new int [] {1,2,3,4,5,6,7,8,9} ;
ArrayUtil.reverse(data) ; // 轉置處理
ArrayUtil.printArray(data) ;
}
}
9數組相關類操作方法
Java語言本身提供有數組的相關支持處理。
a：數組排序：Java.util.Arrays.sort(數組名稱)
class ArrayUtil {
public static void printArray(int temp []) {
for (int x = 0 ; x < temp.length ; x ++) {
System.out.print(temp[x] + "、") ;
}
System.out.println() ;
}
}
public class ArrayDemo {
public static void main(String args[]) {
int data [] = new int [] {23,12,1,234,2,6,12,34,56} ;
java.util.Arrays.sort(data) ; // 排序
ArrayUtil.printArray(data) ;
}
}
b：數組拷貝：System.arraycopy(源數組，源數組開始點，目標數組，目標數組開始點，拷貝長度)
class ArrayUtil {
public static void printArray(int temp []) {
for (int x = 0 ; x < temp.length ; x ++) {
System.out.print(temp[x] + "、") ;
}
System.out.println() ;
}
}
public class ArrayDemo {
public static void main(String args[]) {
int dataA [] = new int [] {1,2,3,4,5,6,7,8,9} ;
int dataB [] = new int [] {11,22,33,44,55,66,77,88,99} ;
System.arraycopy(dataA,5,dataB,3,3) ;
ArrayUtil.printArray(dataB) ;
}
}
//結果：
11、22、33、6、7、8、77、88、99、
10方法可變參數
需求：定義一個方法，可以實現任意多個整型數據的相加處理。
傳統實現。
class ArrayUtil {
public static int sum(int [] data) {
int sum = 0 ;
for (int temp : data) {
sum += temp ;
}
return sum ;
}
}
public class ArrayDemo {
public static void main(String args[]) {
System.out.println(ArrayUtil.sum(new int [] {1,2,3})) ;
}
}
上述代碼可以實現任意多個數字的參數內容傳遞，但是與實際的要求并不符合，實際要求的是可以傳遞任意多個參數，而不是一個數組。
從JDK1.5開始為了方便開發組進行可變參數的定義。
class ArrayUtil {
public static int sum(int ... data) { // 變種數組
int sum = 0 ;
for (int temp : data) {
sum += temp ;
}
return sum ;
}
}
public class ArrayDemo {
public static void main(String args[]) {
System.out.println(ArrayUtil.sum(1,2,3,4)) ;
System.out.println(ArrayUtil.sum(new int [] {1,2,3})) ;
}
}
//輸出
10
6
總結：可變參數的最大作用：在以后進行一些程序類設計或者開發者調用的時候，利用次種形式可以避免數組的傳遞操作；可變參數的本質：依然屬于數組。
11對象數組（重點）
之前接觸到的都是基本數據類型定義的數組；Java程序中各種數據類型都可以成為數組類型，所以類也可以成為數組類型：對象數組。
動態初始化： 類 對象數組名稱 【】 = new 類 【長度】；
靜態初始化： 類 對象數組名稱 【】 = new 類 【】{實例化對象，實例化對象，… }；
動態初始化每個元素為null；
//動態初始化
class Person {
private String name ;
private int age ;
public Person(String name,int age) {
this.name = name ;
this.age = age ;
}
public String getInfo() {
return "姓名：" + this.name + "、年齡：" + this.age ;
}
// setter、getter略
}
public class ArrayDemo {
public static void main(String args[]) {
Person per [] = new Person[3] ; // 對象數組
per[0] = new Person("張三",20) ;
per[1] = new Person("李四",20) ;
per[2] = new Person("王五",20) ;
for (int x = 0 ; x < per.length ; x ++) {
System.out.println(per[x].getInfo()) ;
}
}
}
//靜態初始化
class Person {
private String name ;
private int age ;
public Person(String name,int age) {
this.name = name ;
this.age = age ;
}
public String getInfo() {
return "姓名：" + this.name + "、年齡：" + this.age ;
}
// setter、getter略
}
public class ArrayDemo {
public static void main(String args[]) {
Person per [] = new Person[] {
new Person("張三",20) ,
new Person("李四",20) ,
new Person("王五",20)} ; // 對象數組
for (int x = 0 ; x < per.length ; x ++) {
System.out.println(per[x].getInfo()) ;
}
}
}
對于對象數組而言，上述代碼只是更換了一種所謂的數組定義的類型，但是內存圖變得復雜：
總結
數組最大缺陷：
長度是固定的；
優勢：線性保存，根據索引訪問，速度較塊。（時間復雜度為“1”）。
面試題：定義類的時候什么情況下會考慮使用static方法？
在類中不提供任何成員屬性的情況下，如果定義的是普通方法，那么就必須通過實例化對象來進行調用，這樣就會產生許多無用的實例化對象。那么在這樣的情況下會考慮直接定義static方法，這樣可以由類名稱直接調用。
更多關于java相關內容感興趣的讀者可查看本站專題：《Java數組操作技巧總結》、《Java字符與字符串操作技巧總結》、《Java數學運算技巧總結》、《Java數據結構與算法教程》及《Java操作DOM節點技巧總結》
希望本文所述對大家java程序設計有所幫助。
免責聲明：本站發布的內容（圖片、視頻和文字）以原創、轉載和分享為主，文章觀點不代表本網站立場，如果涉及侵權請聯系站長郵箱：is@yisu.com進行舉報，并提供相關證據，一經查實，將立刻刪除涉嫌侵權內容。
