数组
数组的概念
用来存储数据的，多个变量组成的一个整体，用来便于批量操作数据的。
元素：每一个数组中的变量空间。
格式：
数组名称[索引]
索引:每个元素的编号 称为索引，从0开始。又叫角标。
长度：数组中可以存储多少个数据。用length表示
数组的声明和赋值:
① 动态初始化:
数据类型[] 数组名称 = new 数据类型[长度]
注意：
-
由于动态初始化开辟空间之后，赋的是数组数据类型的默认值。
-
数据类型[]中 [] 可以跟在数据类型的后面，也可以跟在数组名称的后面。
例如 :
int[] arr
int arr[] 写法都对。
② 静态初始化 :
数据类型[] 数组名称 = new 数据类型[]{数据值1,数据值2,数据值3}
注意：
-
静态初始化 创建数组的时候，就被赋值了，有初始值 。
-
new 数据类型[]里面不放长度值，由{}里面的数据个数决定长度。
③ 静态初始化的简写形式:
数据类型[] 数组名称 = {数据值1,数据值2,数据值3}
注意：
- 声明与赋值不能分开写
/**
① 动态初始化:
数据类型[] 数组名称 = new 数据类型[长度]
② 静态初始化 :
数据类型[] 数组名称 = new 数据类型[]{数据值1,数据值2,数据值3}
③ 静态初始化的简写形式:
数据类型[] 数组名称 = {数据值1,数据值2,数据值3}
注意：
1》 声明与赋值不能分开写。
*/
class 数组概述
{
public static void main(String[] args)
{
//学生 40人
//40变量
int score = 98;
int score1 = 90;
//声明一个数组 ，用来存储学生的成绩 3个学生 成绩分别为 98 90 79
int[] scores = new int[3];
//System.out.println(scores[1]);
scores[0] = 98;//索引为0的数组元素赋值
scores[1] = 90;
scores[2] = 79;
//System.out.println( scores[1]);
String[] arr = new String[3];
//System.out.println(arr[0]);
//长度
//System.out.println(scores.length);
//静态初始化 数据类型[] 数组名称 = new 数据类型[]{数据值1,数据值2,数据值3}
double[] drr = new double[]{1.2,3.5,4.8,6.9};
//③ 静态初始化的简写形式:
//数据类型[] 数组名称 = {数据值1,数据值2,数据值3}
//声明与赋值不能分开写。
char[] crr = {'a','b','c','d'};
}
}
数组的遍历
将数组中的元素依次拿出来，输出一遍
采用for循环的形式
代码
class 数组的遍历 {
public static void main(String[] args) {
//声明一个数组
int[] arr = {1,2,3,4,5,6,7,8};
for (int i = 0; i<arr.length ;i++ ) {
System.out.println(arr[i]);
}
}
}
数组的常见异常
1.数组角标越界异常：访问到了数组索引之外的空间。
ArrayIndexOutOfBoundsException
2.空指针异常: 对象为null
NullPointerException
数组的常见应用
求最值
标志位法
代码
/**
1.求最大值:
标志位法：
思路：
假设 数组的第一个元素是最大的，找一个变量空间存放该值。
*/
class 数组的求最值 {
public static void main(String[] args) {
int[] arr = {1,-5,23,-48,90,25};
//标记最大值 int max = arr[0];
//标记最小值 int min = arr[0];
for (int i = 0 ; i< arr.length ;i++ ) {
//判断最大值
if(max < arr[i]){
max = arr[i];
}
//判断最小值
if( min > arr[i]){
min = arr[i];
}
}
System.out.println(max);
System.out.println(min);
}
}
数组的倒序/逆序
例如：
{1,2,3,4,5,6} ===> 倒序{ 6,5,4,3,2,1}
代码
/**
思路：
通过开始 和结束 标记指针的位置，来进行交换
*/
class 数组的倒序 {
public static void main(String[] args) {
int[] arr ={1,2,3,4,5,6,7};
/*for (int i = arr.length-1; i>=0 ; i-- )
{
System.out.println(arr[i]);
}*/
//开始指针 结束指针
int start = 0;
int end = arr.length-1;
for (;start <= end ; start++,end-- ) {
//交换
int temp = arr[start];
arr[start]= arr[end];
arr[end] = temp;
}
//遍历数组
for (int i = 0; i<arr.length; i++ ) {
System.out.println(arr[i]);
}
}
}
数组的字符串拼接形式
默认打印数组时，打印的实际是数组的对象的形式。需要自己写方法，来显示数组中的元素值
代码：
class 数组的字符串拼接形式 {
public static void main(String[] args) {
int[] arr1 = {1,2,3,4,5};
System.out.println(arrayToString(arr1));
int[] arr2 = {-10,28,19,30};
System.out.println(arrayToString(arr2));
}
//arrayToString 转字符串
public static String arrayToString(int[] arr){
String value = "{";
for (int i=0; i<arr.length ;i++ ) {
value += arr[i];
if(i != arr.length-1 ){
value += ",";
}
}
value += "}";
return value;
}
}
数组内存图
一个引用指向一个数组
1.当main方法开始压栈执行时，在main方法中开辟arr的引用变量空间。
2.在堆中创建数组对象，并进行初始化，如果是动态初始化的形式 ，数组中的值就是数据类型的默认 值，由于此时是静态初始化的简写形式，里面存放的就是初始值。
3.当数组对象初始化完毕之后，将内存首地址赋值给引用变量arr.
总结：
① arr 称为引用变量，并不是真实的数组。空间开辟在栈中。
② 真实的数组对象，空间开辟在堆中。
两个引用指向同一个数组
排序
概述
1.冒泡排序（Bubble Sort）
思路：
它重复地走访过要排序的元素列，依次比较两个相邻的元素，
如果顺序（如从大到小、首字母从Z到A）错误就把他们交换过来。
走访元素的工作是重复地进行直到没有相邻元素需要交换，也就是说该元素列已经排序完成
2.排序的方式:
① 升序排序：从小到大
② 降序排序: 从大到下
代码
/**
1.冒泡排序（Bubble Sort）
思路：
它重复地走访过要排序的元素列，依次比较两个相邻的元素，
如果顺序（如从大到小、首字母从Z到A）错误就把他们交换过来。
走访元素的工作是重复地进行直到没有相邻元素需要交换，也就是说该元素列已经排序完成
2.排序的方式:
① 升序排序：从小到大
② 降序排序: 从大到下
*/
class 冒泡排序 {
public static void main(String[] args) {
int[] arr = {-19,23,38,47,15,19,-30};
//外层控制比多少趟
for (int i = 0 ; i<arr.length ;i++ ) {
for (int j = 0; j< arr.length -1 /*-i*/ ; j++ ) {
//第一个数大于第二个数 升序 就交换
if( arr[j] > arr[j+1]){
int temp = arr[j];
arr[j] = arr[j+1];
arr[j+1] = temp;
}
}
}
System.out.println(arrayToString(arr));
}
//arrayToString 转字符串
public static String arrayToString(int[] arr){
String value = "{";
for (int i=0; i<arr.length ;i++ ) {
value += arr[i];
if(i != arr.length-1 ){
value += ",";
}
}
value += "}";
return value;
}
}
二维数组
多维数组
java中 没有多维数组的概念，所谓的多维数组，实质就是数组套数组。
二维数组声明与赋值
① 动态初始化
数据类型[][] 数组名称 = new 数据类型[长度][长度];`
② 静态初始化
**数据类型 数组名称 = new 数据类型*{*{*}{*}*,*{*}*}*;**
③ 静态初始化的简写形式
数据类型[][] 数组名称 = *{*{*}*,*{*}*,*{*}*}*;
二维数组的内存图
1.二维数组声明与赋值
① 动态初始化
数据类型[][] 数组名称 = new 数据类型[长度1][长度2];
注意：
长度2可以省略不写的。
但是省略后，需要先赋值再使用。
② 静态初始化
数据类型[][] 数组名称 = new 数据类型[][]*{*{*}*,*{*}*,*{*}*};
③ 静态初始化的简写形式
数据类型[][] 数组名称 = *{*{*}*,*{*}*,*{*}*};
2.默认值：
基本数据类型：
整数类型： byte short int long 0
浮点数类型:float double 0.0
布尔类型: false
字符类型:’\u0000'
引用数据类型:
null
结论：
① 第一个[]表示外层的数组。第二个[]表示内层的嵌套数组。
② 外层的数组中存储的内层嵌套数组的引用地址。
代码
/**
1.二维数组声明与赋值
① 动态初始化
数据类型[][] 数组名称 = new 数据类型[长度1][长度2];
注意：
长度2可以省略不写的。
但是省略后，需要先赋值再使用。
② 静态初始化
数据类型[][] 数组名称 = new 数据类型[][]{{},{},{}}
③ 静态初始化的简写形式
数据类型[][] 数组名称 = {{},{},{}}
2.默认值：
基本数据类型：
整数类型： byte short int long 0
浮点数类型:float double 0.0
布尔类型: false
字符类型:'\u0000'
引用数据类型:
null
3.二维数组的遍历：
*/
class 二维数组 {
public static void main(String[] args) {
//① 动态初始化
int[][] arr = new int [3][5];
//System.out.println(arr[0][0]);
//System.out.println(arr[0]);
//③ 静态初始化的简写形式
int[][] arr1 = {**{1,2,3},{4,5},{7,8,9,10}**};
//System.out.println(arr1[0][1]);
//System.out.println(arr1[1][0]);
//System.out.println(arr1[2][2]);
//② 静态初始化
int[][] arr2 = new int[][]{**{1,2,3},{4,5},{7,8,9,10}**};
//System.out.println(arr2[1][0]);
//动态初始化需要注意的问题：但是省略后，需要先赋值再使用。
int[][] arr3 = new int[3][];
arr3[1] = new int[3];
//System.out.println(arr3[1][0]);
//二维数组的遍历:
for (int i = 0; i<arr2.length ;i++ ) {
for (int j = 0; j<arr2[i].length ; j++) {
System.out.print( arr2[i][j] +"\t");
}
System.out.println();
}
}
}