Java數組聲明建立和使用以及多維數組、Arrays類、稀疏數組
目錄
數組概述
- 數組是相同類型數組的有序集合
- 數組描述的是相同的類型的若干個數據，按照必定的前後次序排列組合而成
- 其中，每個數據稱做一個數組元素，每一個數組元素能夠經過一個下標來訪問它們
數組聲明建立
首先必須聲明數組變量，才能在程序中使用數組。下面是聲明數組變量的語法：java
dataType[] arrayRefVar;//首選的方法 dataType arrayRefVar[];//效果相同，但不是首選方法
java語言使用new操做符來建立數組，語法以下：小程序
dataType[] arrayRefVar = new dataType[arraySize];
數組的元素是經過索引訪問的，數組索引從0開始數組
獲取數組長度：arrays.length工具
public class ArrayDemo01 {
public static void main(String[] args) {
//數組類型 數組的名字 = 數組的值;
int[] nums;//聲明一個數組
int nums2[];//也是定義，但不首選
nums = new int[10];//給聲明的數組分配空間，建立數組。這裏面能夠存放10個int類型的數字
//給數組元素中賦值
nums[0]=1;
nums[1]=2;
nums[2]=3;
nums[3]=4;
nums[4]=5;
nums[5]=6;
nums[6]=7;
nums[7]=8;
nums[8]=9;
System.out.println(nums[9]);//0 不賦值的話，默認值爲0
//計算全部元素的和
int sum = 0;
for (int i = 0; i < nums.length; i++) {
sum=sum+nums[i];
}
System.out.println(sum);//45
}
}
內存分析
java內存分析
堆
存放new的對象和數組線程
能夠被全部線程共享，不會存放別的對象引用code
棧
存放基本變量類型（會包含這個基本類型的具體數值）對象
引用對象的變量（會存放這個引用在堆裏面的具體地址）排序
方法區
能夠被全部的線程共享索引
包含了全部的class和static變量內存
三種初始化
靜態初始化
建立+賦值
int[] a ={1,2,3};
Man[] mans = {new Man(1,1),new Man(2,2)};//須要先建立相關類
動態初始化
包含默認初始化
int[] a = new int[2]; a[0]=1; a[1]=2;
數組的默認初始化
數組是引用類型，他的元素至關於類的實例變量，所以數組一經分配空間，其中的每一個元素也被按照實例變量一樣的方式被隱式初始化
數組的四個基本特色
- 其長度是肯定的。數組一旦被建立，它的大小就是不能夠被改變的
- 其元素必須是相同類型，不巡視出現混合類型
- 數組中的元素能夠試試任何數據類型，包括基本類型和引用類型
- 數組變量屬於引用類型，數組也能夠當作是對象，數組中的每一個元素至關於該對象的成員變量。
數組自己就是對象，java中對象是在堆中的，所以數組不管保存原始類型仍是其餘對象類型，數組對象自己是在堆中的。
數組邊界
下標的合法區間：[0,length-1],若是越界就會報錯；
int [] a = new int[3]; System.out.println(a[3]);//ArrayIndexOutOfBoundsException:數組下標越界異常
小結：
- 數組是相同數組類型（數據類型能夠爲任意類型）的有序集合
- 數組也是對象。數組元素至關於對象的成員變量
- 數組長度的肯定的，不可變的。若是越界，則報：ArrayIndexOutOfBoundsException
數組使用
數組基礎使用
public class ArrayDemo02 {
public static void main(String[] args) {
int[] arrays = {1,2,3,4,5};
//打印所有數組元素
for (int i = 0; i < arrays.length; i++) {
System.out.print(arrays[i]);//12345
}
//計算全部元素的和
int sum = 0;
for (int i = 0; i < arrays.length; i++) {
sum+=arrays[i];
}
System.out.println("sum="+sum);//sum=15
System.out.println("==================================");
//查找最大元素
int max = arrays[0];
for (int i = 1; i < arrays.length; i++) {
if(max<arrays[i]){
max=arrays[i];
}
}
System.out.println("max="+max);//max=5
}
}
For Each循環和普通for循環
public class ArrayDemo03 {
public static void main(String[] args) {
int[] arrays = {1,2,3,4,5};
//for-each 沒有下標
for (int array : arrays) {
System.out.print(array);//取出每個值12345
}
int[] reverse = reverse(arrays);
printArray(reverse);//54321
}
//打印數組元素，數組能夠作方法入參
public static void printArray(int[] arrays){
for (int i = 0; i < arrays.length; i++) {
System.out.print(arrays[i]);//12345
}
}
//反轉數組
public static int[] reverse(int[] arrays){
int[] result = new int[arrays.length];
//反轉操做
for (int i = 0,j=result.length-1; i < arrays.length; i++,j--) {
result[j]=arrays[i];
}
return result;//數組做爲返回值
}
}
多維數組
多維數組能夠當作是數組的數組，好比二維數組就是一個特殊的一維數組，其中每個元素都是一個一維數組
二維數組
int a[][] = new int[2][5];//能夠當作一個兩行五列的數組
遍歷二維數組
public class ArrayDemo04 {
public static void main(String[] args) {
int[][] array = {{1,2,3},{2,3,4},{3,4,5}};//建立二維數組[3][3]
/*
1,2,3 array[0]
2,3,4 array[1]
3,4,5 array[2]
*/
printArray(array[1]);//234
System.out.println(array[0][2]);//3
System.out.println(array.length);//3
System.out.println(array[0].length);//3
//遍歷二維數組
for (int i = 0; i < array.length; i++) {
for (int j = 0; j < array[i].length; j++) {
System.out.println(array[i][j]);//123 234 345
}
}
}
//打印數組元素
public static void printArray(int[] arrays){
for (int i = 0; i < arrays.length; i++) {
System.out.print(arrays[i]);//12345
}
}
}
Arrays類
數組的工具類java.util.Arrays；
因爲數組對象自己並無什麼方法能夠供咱們調用，但API中提供了一個工具類Arrays供咱們使用，從而能夠對數據對象進行一些基本操做
Arrays類中的方法都是static修飾的靜態方法，在使用的時候能夠直接使用類名進行調用，而「不用」使用對象來調用("不用"而不是"不能")
具體如下經常使用功能：
- 給數組賦值：經過fill方法
- 對數組排序：經過sort方法，按升序
- 比較數組：經過equals方法比較數組中元素值是否相等
- 查找數組元素：經過binarySearch方法能對排序好的數組進行二分查找法操做
package com.shenxiaoyu.array;
import java.lang.reflect.Array;
import java.util.Arrays;
public class ArrayDemo05 {
public static void main(String[] args) {
int[] a = {1,2,3,4,9090,32311,643,21,3,3,23};
System.out.println(a);//[I@16d3586
//打印數組元素Arrays.toString
//System.out.println(Arrays.toString(a));//[1, 2, 3, 4, 9090, 32311, 643, 21, 3, 3, 23]
printArray(a);
Arrays.sort(a);//數組進行排序：升序
System.out.println(Arrays.toString(a));//[1, 2, 3, 3, 3, 4, 21, 23, 643, 9090, 32311]
Arrays.fill(a,0);//數組填充
System.out.println(Arrays.toString(a));//[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
}
//打印數組元素
public static void printArray(int[] a){
for (int i = 0; i < a.length; i++) {
if (i==0){
System.out.print("[");
}
if(i==a.length-1){
System.out.print(a[i]+"]");
}else{
System.out.print(a[i]+",");
}
}
}
}
稀疏數組
當一個數組中大部分爲-，或者爲同一值的數組時，可使用稀疏數組來保存該數組
稀疏數組的處理方式：
- 記錄數組一共有幾行幾列，有多少不一樣值
- 把具備不一樣值的元素和行列及值記錄在一個小規模數組中，從而縮小程序的規模。
package com.shenxiaoyu.array;
import java.util.jar.JarOutputStream;
public class ArrayDemo07 {
public static void main(String[] args) {
//1.建立一個二維數組 11*11 0：沒有棋子 1：黑棋 2：白棋
int[][] array1 = new int[11][11];
array1[1][2] = 1;
array1[2][3] = 2;
//輸出原始的數組
System.out.println("輸出原始的數組");
for (int[] ints : array1) {
for (int anInt : ints) {
System.out.print(anInt+"\t");
}
System.out.println();
}
/*
輸出原始的數組
0 0 0 0 0 0 0 0 0 0 0
0 0 1 0 0 0 0 0 0 0 0
0 0 0 2 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0
*/
//轉換爲稀疏數組來保存
//獲取有效值的個數
int sum = 0;
for (int i = 0; i < array1.length; i++) {
for (int j = 0; j < array1.length; j++) {
if(array1[i][j]!=0){
sum++;
}
}
}
System.out.println("有效值的個數："+sum);
//建立一個稀疏數組的數組
int[][] array2 = new int[sum+1][3];
array2[0][0]=11;
array2[0][1]=11;
array2[0][2]=sum;
//遍歷二維數組，將非零的值，存放稀疏數組中
int count = 0;
for (int i = 0; i < array1.length; i++) {
for (int j = 0; j < array1[i].length; j++) {
if (array1[i][j]!=0){
count++;
array2[count][0] = i;
array2[count][1] = j;
array2[count][2] = array1[i][j];
}
}
}
//輸出稀疏數組
System.out.println("稀疏數組");
for (int i = 0; i < array2.length; i++) {
System.out.println(array2[i][0]
+"\t"+array2[i][1]
+"\t"+array2[i][2]);
}
/*
有效值的個數：2
稀疏數組
11 11 2
1 2 1
2 3 2
*/
System.out.println("====================================");
System.out.println("還原");
//讀取稀疏數組
int[][] array3 = new int[array2[0][0]][array2[0][1]];
//給其中的元素還原他的值
for (int i = 1; i < array2.length; i++) {
array3[array2[i][0]][array2[i][1]] = array2[i][2];
}
//打印
System.out.println("輸出還原的數組");
for (int[] ints : array3) {
for (int anInt : ints) {
System.out.print(anInt+"\t");
}
System.out.println();
}
/*
還原
輸出還原的數組
0 0 0 0 0 0 0 0 0 0 0
0 0 1 0 0 0 0 0 0 0 0
0 0 0 2 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0
*/
}
}
相關文章
- 1. 稀疏數組
- 2. JavaScript稀疏數組
- 3. 稀疏sparsearray數組
- 4. C#數組--(一維數組，二維數組的聲明，使用及遍歷)
- 5. 數組及Arrays類
- 6. Java數組--Arrays類
- 7. 數據結構與算法-稀疏數組與二維數組
- 8. 數據結構 稀疏數組的壓縮和稀疏數組的還原.
- 9. JAVA算法-稀疏數組和隊列
- 10. java數組 數組工具類Arrays
- 更多相關文章...
- • C# 多維數組 - C#教程
- • PHP 多維數組 - PHP教程
- • Flink 數據傳輸及反壓詳解
- • TiDB 在摩拜單車在線數據業務的應用和實踐
相關標籤/搜索
每日一句
-
每一个你不满意的现在，都有一个你没有努力的曾经。
最新文章
- 1. 融合阿里雲，牛客助您找到心儀好工作
- 2. 解決jdbc(jdbctemplate)在測試類時不報錯在TomCatb部署後報錯
- 3. 解決PyCharm GoLand IntelliJ 等 JetBrains 系列 IDE無法輸入中文
- 4. vue+ant design中關於圖片請求不顯示的問題。
- 5. insufficient memory && Native memory allocation (malloc) failed
- 6. 解決IDEA用Maven創建的Web工程不能創建Java Class文件的問題
- 7. [已解決] Error: Cannot download ‘https://start.spring.io/starter.zip?
- 8. 在idea讓java文件夾正常使用
- 9. Eclipse啓動提示「subversive connector discovery」
- 10. 帥某-技巧-快速轉帖博主文章（article_content）
歡迎關注本站公眾號,獲取更多信息
相關文章
- 1. 稀疏數組
- 2. JavaScript稀疏數組
- 3. 稀疏sparsearray數組
- 4. C#數組--(一維數組，二維數組的聲明，使用及遍歷)
- 5. 數組及Arrays類
- 6. Java數組--Arrays類
- 7. 數據結構與算法-稀疏數組與二維數組
- 8. 數據結構 稀疏數組的壓縮和稀疏數組的還原.
- 9. JAVA算法-稀疏數組和隊列
- 10. java數組 數組工具類Arrays