JAVA語言基礎-數組
一維數組
什麼是數組
/*
* A:爲何要有數組(容器)
* 爲了存儲同種數據類型的多個值
* B:數組概念
* 數組是存儲同一種數據類型多個元素的集合。也能夠當作是一個容器。
* 數組既能夠存儲基本數據類型，也能夠存儲引用數據類型。
* C:數組定義格式
數據類型[] 數組名 = new 數據類型[數組的長度];
*/
class Demo1_Array {
public static void main(String[] args) {
int x = 10;
x = 20;
System.out.println("x = " + x);
//數據類型[] 數組名 = new 數據類型[數組的長度];
int[] arr = new int[5]; //能夠存儲五個int類型的數據
/*
左邊:
int:數據類型
[]:表明的數組,幾個中括號就表明幾維數組
arr:合法的標識符
右邊:
new:建立新的實體或對象
int:數據類型
[]:表明的數組
5:表明數組的長度
*/
}
}
數組的初始化
/*
* A:什麼是數組的初始化
* 就是爲數組開闢連續的內存空間，併爲每一個數組元素賦予值
* B:如何對數組進行初始化
* a:動態初始化 只指定長度，由系統給出初始化值
* int[] arr = new int[5];
* b:靜態初始化 給出初始化值，由系統決定長度
* C:動態初始化的格式：
* 數據類型[] 數組名 = new 數據類型[數組長度];
* D:案例演示
* 輸出數組名稱和數組元素
整數類型:byte,short,int,long默認初始化值都是0
浮點類型:float,double默認初始化值都是0.0
布爾類型:boolean默認初始化值false
字符類型:char默認初始化值'\u0000'
char在內存中佔的兩個字節,是16個二進制位
\u0000,每個0其實表明的是16進制的0,那麼四個0就是表明16個二進制位
[I@19bb25a
[表明是數組,幾個就表明幾維
I表明是int類型
@是固定的
19bb25a表明的是數組的地址值
*/
class Demo2_Array {
public static void main(String[] args) {
//數據類型[] 數組名 = new 數據類型[數組長度];
int[] arr = new int[5]; //動態初始化,在內存中開闢連續的5塊空間
System.out.println(arr[0]); //系統給出默認初始化值,整數類型的都是0
arr[0] = 10;
System.out.println(arr[0]);
System.out.println(arr); //[I@19bb25a
}
}
堆棧方法區
/*
* A:棧(掌握)
* 存儲局部變量
局部變量:定義在方法聲明上和方法中的變量
* B:堆(掌握)
* 存儲new出來的數組或對象
* C:方法區
* 面向對象部分講解
* D:本地方法區
* 和系統相關
* E:寄存器
* 給CPU使用
*/
class Demo3_Array {
public static void main(String[] args) {
int[] arr = new int[3]; //動態初始化,建立3塊連續的空間
System.out.println(arr);
arr[0] = 10;
arr[1] = 20;
System.out.println(arr[0]);
System.out.println(arr[1]);
}
}
數組元素賦值
int[] arr1 = new int[3]; //建立數組,長度爲3 int[] arr2 = new int[3]; //建立數組,長度爲3 System.out.println(arr1); //打印數組的地址值 System.out.println(arr2); arr1[0] = 10; //給第一個數組中第一個元素賦值 arr2[1] = 20; //給第二個數組中第二個元素賦值
三個引用兩個數組
int[] arr1 = new int[3]; int[] arr2 = new int[5]; int[] arr3 = arr2; System.out.println(arr1); System.out.println(arr2); System.out.println(arr3); arr1[0] = 10; arr1[1] = 20; arr2[1] = 30; arr3[1] = 40; arr3[2] = 50;
數組的靜態初始化
/*
* A:靜態初始化的格式：
* 格式：數據類型[] 數組名 = new 數據類型[]{元素1,元素2,…};
* 簡化格式：
* 數據類型[] 數組名 = {元素1,元素2,…};
* B:案例演示
* 對數組的解釋
* 輸出數組名稱和數組元素
* C:畫圖演示
* 一個數組
*/
class Demo6_Array {
public static void main(String[] args) {
//數據類型[] 數組名 = new 數據類型[]{元素1,元素2,…};
//int[] arr = new int[5]{11,22,33,44,55}; //不容許動靜結合
int[] arr2 = {11,22,33,44,55}; //靜態初始化的簡寫形式
//int[] arr; //聲明數組引用
//arr = new int[]{11,22,33,44,55};
//int[] arr2;
//arr2 = {11,22,33,44,55}; //簡寫形式聲明和賦值在同一行
System.out.println(arr2);
System.out.println(arr2[4]);
}
ArrayIndexOutOfBoundsException
/*
* A:案例演示
* a:ArrayIndexOutOfBoundsException:數組索引越界異常
* 緣由：你訪問了不存在的索引。
* b:NullPointerException:空指針異常
* 緣由：數組已經不在指向堆內存了。而你還用數組名去訪問元素。
* int[] arr = {1,2,3};
* arr = null;
* System.out.println(arr[0]);
*/
class Demo7_Exception {
public static void main(String[] args) {
int[] arr = new int[5]; //0x0011
//System.out.println(arr[-1]); //當訪問數組中不存在的索引,會出現索引越界異常
arr = null;
System.out.println(arr[0]); //當數組引用賦值爲null,再去調用數組中的元素就會出現空指針異常
}
}
數組的遍歷
/*
* A:案例演示
* 數組遍歷：就是依次輸出數組中的每個元素。
* 數組的屬性:arr.length數組的長度
* 數組的最大索引:arr.length - 1;
*/
class Demo8_Array {
public static void main(String[] args) {
int[] arr = {11,22,33,44,55};
for (int i = 0;i < 5 ;i++ ) {
System.out.println(arr[i]);
}
System.out.println("---------------");
//arr.length 表明的是數組的長度
System.out.println(arr.length);
for (int i = 0;i < arr.length ;i++ ) {
System.out.println(arr[i]);
}
int[] arr2 = {3,4,5};
print(arr2);
}
/*
數組的遍歷
1,返回值類型void
2,參數列表int[] arr
*/
public static void print(int[] arr) {
for (int i = 0;i < arr.length ;i++ ) {
System.out.print(arr[i] + " ");
}
}
}
數組獲取最值
/*
* A:案例演示
* 數組獲取最值(獲取數組中的最大值最小值)
*/
class Demo9_Array {
public static void main(String[] args) {
int[] arr = {33,77,22,44,55};
int max = getMax(arr);
System.out.println(max);
}
/*
獲取數組中最大值
1,返回值類型int
2,參數列表int[] arr
*/
public static int getMax(int[] arr) {
int max = arr[0];
for (int i = 1;i < arr.length ;i++ ) { //從數組的第二個元素開始遍歷
if (max < arr[i]) { //若是max記錄的值小於的數組中的元素
max = arr[i]; //max記錄住較大的
}
}
return max;
}
}
數組元素反轉
/*
* A:案例演示
* 數組元素反轉(就是把元素對調)
*/
class Demo10_Array {
public static void main(String[] args) {
int[] arr = {11,22,33,44,55};
reverseArray(arr);
print(arr);
}
/*
數組元素反轉
1,明確返回值類型void
2,明確參數列表int[] arr
*/
public static void reverseArray(int[] arr) {
for (int i = 0;i < arr.length / 2 ; i++) {
//arr[0]和arr[arr.length-1-0]交換
//arr[1]和arr[arr.length-1-1]交換
//arr[2]和arr[arr.lentth-1-2]
//...
int temp = arr[i];
arr[i] = arr[arr.length-1-i];
arr[arr.length-1-i] = temp;
}
}
/*
數組遍歷
1,明確返回值類型void
2,明確參數列表int[] arr
*/
public static void print(int[] arr) {
for (int i = 0;i < arr.length ;i++ ) { //遍歷數組中的每個元素
System.out.print(arr[i] + " "); //打印在控制檯
}
}
}
數組查表法
/*
* A:案例演示
* 數組查表法(根據鍵盤錄入索引,查找對應星期)
*/
import java.util.Scanner;
class Demo11_Array {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
System.out.println("請輸入對應的星期範圍在1-7");
int week = sc.nextInt();
System.out.println("星期" + getWeek(week));
}
/*
根據索引返回對應的星期
1,返回值類型char
2,參數列表int week
*/
public static char getWeek(int week) {
char[] arr = {' ','一','二','三','四','五','六','日'}; //定義了一張星期表
return arr[week]; //經過索引獲取表中的元素
}
}
數組元素查找
/*
* A:案例演示
* 數組元素查找(查找指定元素第一次在數組中出現的索引)
*/
class Demo12_Array {
public static void main(String[] args) {
int[] arr = {11,22,33,44,55,66,77};
int index = getIndex(arr,88);
System.out.println(index);
}
/*
查找元素索引
1,返回值類型int
2,明確參數列表,int[] arr,int value
*/
public static int getIndex(int[] arr,int value) {
for (int i = 0;i < arr.length ;i++ ) { //數組的遍歷
if (arr[i] == value) { //若是數組中的元素與查找的元素匹配
return i;
}
}
return -1;
}
}
數組遍歷
public static void main(String[] args) {
//定義一個數組,靜態初始化
int[] arr = {10,20,13,15,25,10,15};
//數組遍歷: 遍歷是什麼意思? 把數組中的每一個元素一個個拿出來看一下
//System.out.println(arr[0]);
//arr.length 屬性:數組名.length
for (int i = 0;i < arr.length ;i++ ){ //數組中有多少個元素,我就幫你一個個打印出來 //細節 別寫=號
System.out.println(arr[i]); //
}
}
數組的倒序
public static void main(String[] args) {
//第一步 建立一個數組
int [] arr = {11,22,33,44,55};
//第二步: reverseArr
int[] newArr = reverseArr(arr);
for (int j = 0;j < newArr.length ;j++ )
{
System.out.print(newArr[j] + " ");
}
}
public static int[] reverseArr(int[] oldArr){
//思想
//第一步 建立一個新的數組,而後長度和你傳進來的數組長度同樣
//第二步 把舊的數組元素 從後面開始 往前一個個 存到新的數組裏面
int [] newArr = new int[oldArr.length];
//第三步 遍歷
for (int i = 0;i < oldArr.length ;i++ )
{
newArr[i] = oldArr[oldArr.length - 1 - i];
}
return newArr;
/*
for (int j = 0;j < newArr.length ;j++ )
{
System.out.print(newArr[j] + " ");
}*/
}
二維數組
概述
/*
* A:二維數組概述
* B:二維數組格式1
* int[][] arr = new int[3][2];
* C:二維數組格式1的解釋
* D:注意事項
* a:如下格式也能夠表示二維數組
* 1:數據類型 數組名[][] = new 數據類型[m][n];
* 2:數據類型[] 數組名[] = new 數據類型[m][n];
* B:注意下面定義的區別
*
int x;
int y;
int x,y;
int[] x;
int[] y[];
int[] x,y[]; x是一維數組,y是二維數組
* E:案例演示
* 定義二維數組，輸出二維數組名稱，一維數組名稱，一個元素
*/
class Demo1_Array {
public static void main(String[] args) {
int[][] arr = new int[3][2];
/*
這是一個二維數組
這個二維數組中有3個一維數組
每一個一維數組中有2個元素
[[I@19bb25a //二維數組的地址值
[I@da6bf4 //一維數組的地址值
0 //元素值
*/
System.out.println(arr); //二維數組
System.out.println(arr[0]); //二維數組中的第一個一維數組
System.out.println(arr[0][0]); //二維數組中的第一個一維數組的第一個元素
}
}
二維數組輸出
/*
* A:畫圖演示
* 畫圖講解上面的二維數組名稱，一維數組名稱，一個元素的值的問題
*/
class Demo2_Array {
public static void main(String[] args) {
int[][] arr = new int[3][2];
System.out.println(arr); //打印二維數組
System.out.println(arr[0]); //打印二維數組中的第一個一維數組
System.out.println(arr[0][0]); //打印二維數組中的第一個一維數組中的第一個元素
}
}
二維數組格式2
/*
* A:二維數組格式2
* int[][] arr = new int[3][];
* B:二維數組格式2的解釋
* C:案例演示
* 講解格式，輸出數據，並畫內存圖
*/
class Demo3_Array {
public static void main(String[] args) {
int[][] arr = new int[3][]; //這是一個二維數組,這個二維數組中有三個一維數組,三個一維數組都沒有被賦值
System.out.println(arr[0]);
System.out.println(arr[1]);
System.out.println(arr[2]);
arr[0] = new int[3]; //第一個一維數組中能夠存儲三個int值
arr[1] = new int[5]; //第二個一維數組中能夠存儲五個int值
System.out.println("------------------");
System.out.println(arr[0]);
System.out.println(arr[1]);
System.out.println(arr[2]);
}
}
二維數組格式3
/*
* A:二維數組格式3
* int[][] arr = {{1,2,3},{4,5},{6,7,8,9}};
* B:二維數組格式3的解釋
* C:案例演示
* 講解格式，輸出數據，並畫內存圖
*/
class Demo4_Array {
public static void main(String[] args) {
int[][] arr = {{1,2,3},{4,5},{6,7,8,9}}; //這是一個二維數組,這個二維數組中每一個大括號都表明一個一維數組
System.out.println(arr); //[[I@19bb25a,二維數組的地址值
System.out.println(arr[0]); //[I@da6bf4,一維數組的地址值
System.out.println(arr[0][0]); //1,一維數組中的元素值
}
}
維數組遍歷
/*
* A:案例演示
* 需求：二維數組遍歷
* 外循環控制的是二維數組的長度，其實就是一維數組的個數。
* 內循環控制的是一維數組的長度。
*/
class Test1_Array {
public static void main(String[] args) {
int[][] arr = {{1,2,3},{4,5},{6,7,8,9}};
for (int i = 0;i < arr.length ;i++ ) { //獲取到每一個二維數組中的一維數組
for (int j = 0;j < arr[i].length ;j++ ) { //獲取每一個一維數組中的元素
System.out.print(arr[i][j] + " ");
}
System.out.println();
}
}
}
案例演示
/*
* A:案例演示
*
需求：公司年銷售額求和
某公司按照季度和月份統計的數據以下：單位(萬元)
第一季度：22,66,44
第二季度：77,33,88
第三季度：25,45,65
第四季度：11,66,99
*/
class Test2_Array {
public static void main(String[] args) {
int[][] arr = {{22,66,44},{77,33,88},{25,45,65},{11,66,99}};
int sum = 0; //定義變量,記錄每次相加的結果
for (int i = 0;i < arr.length ;i++ ) { //獲取每個一維數組
for (int j = 0;j < arr[i].length ;j++ ) { //獲取每個一維數組中的元素
sum = sum + arr[i][j]; //累加
}
}
System.out.println(sum);
}
}
值傳遞
/*
基本數據類型的值傳遞,不改變原值,由於調用後就會彈棧,局部變量隨之消失
引用數據類型的值傳遞,改變原值,由於即便方法彈棧,可是堆內存數組對象還在,能夠經過地址繼續訪問
Java中究竟是傳值仍是傳址
1,既是傳值,也是傳地址,基本數據類型傳遞的值,引用數據類型傳遞的地址
2,java中只有傳值,由於地址值也是值(出去面試都說這種,支持者是高司令(java之父))
*/
class Test3_Array {
public static void main(String[] args) {
/*int a = 10;
int b = 20;
System.out.println("a:"+a+",b:"+b); //a = 10,b = 20
change(a,b);
System.out.println("a:"+a+",b:"+b); //?*/
int[] arr = {1,2,3,4,5};
change(arr);
System.out.println(arr[1]);
}
public static void change(int a,int b) { //a = 10, b= 20
System.out.println("a:"+a+",b:"+b); //a = 10,b = 20
a = b; //a = 20
b = a + b; //b = 40
System.out.println("a:"+a+",b:"+b); //a = 20, b = 40
}
public static void change(int[] arr) { //1,4,3,8,5
for(int x=0; x<arr.length; x++) {
if(arr[x]%2==0) {
arr[x]*=2;
}
}
}
}
相關文章
- 1. Java語言基礎：數組
- 2. Day04 Java語言基礎組成——數組
- 3. Java語言基礎語法（二）數組
- 4. java語言基礎組成
- 5. day05<Java語言基礎--數組>
- 6. Java語言基礎方法和數組
- 7. Java語言基礎------數組（一）
- 8. day05 java語言基礎（數組）
- 9. 2.4JAVA基礎複習——JAVA語言的基礎組成數組
- 10. 2.3JAVA基礎複習——JAVA語言的基礎組成函數
- 更多相關文章...
- • R 語言基礎 - R 語言教程
- • Kotlin 基礎語法 - Kotlin 教程
- • Kotlin學習（一）基本語法
- • ☆基於Java Instrument的Agent實現
相關標籤/搜索
每日一句
-
每一个你不满意的现在，都有一个你没有努力的曾经。
歡迎關注本站公眾號,獲取更多信息
