数组
概念:存储多个元素并且多个元素是同一种类型的容器
数组的定义:
1)数据类型[] 数组名;
2)数据类型 数组名[];
举例:
int[] a 定义了一个int类型的数组变量a /*推荐使用*/
int a[] 定义了一个int类型变量a数组
这两种方式的定义虽然写法不一样,读法不一样,但是表达的效果一样,都是在定义一个数组,推荐使用第一种方式;
数组的初始化:
1)动态初始化: 给数组指定长度,数组中的元素值由系统默认给定
2)静态初始化: 给定数组元素的值,数组的长度由系统给定;
动态初始化: 数据类型[] 数组名 = new 数据类型[数组长度] ;
举例: int[] arr = new int[3] ;
int[] arr ;
System.out.println(arr);
没有被初始化的数组是不能使用的
Java内存分配空间图解
分析数组初始化语句:
int[] arr = new int[3] ;
左边: 1)int[]: 定义的是一个int类型的数组
2)arr: 数组名称
右边:
1)new :创建一个数组对象(它会在堆内存中创建)
2)int[]: 当前int类型的数组
3) 3: 当前数组的长度是3
如何获取数组中的元素
通过数组名称获取
格式：
数组名称[索引值]，索引值从0开始,最大的索引值为数组长度-1(数组的长度为数组名.length)
举例:
int arr[]=new arr[3];
System.out.println(arr[0]); //输出第一个数组元素
System.out.println(arr[1]); //输出第二个数组元素
System.out.println(arr[2]); //输出第三个数组元素
需求:
1)创建一个数组,先输出数组名称和它的元素值
2)给当前数组中的某些元素进行赋值,然后再输出数组名称和元素值
代码:
Java两个数组的内存分配图解
需求:
1)创建两个数组,分别输出数组名称和数组中的元素2)给两个数组中的某些元素进行赋值,再次分别输出数组名称和数组中元素
Java三个数组的内存分配图解
需求:
1)创建两个数组,分别输出数组名称和元素,给前两个数组进行赋值;
2)创建第三个数组,将第一个数组的名称赋值给第三个数组,通过第三个数组的名称进行赋值,输出第一个数组的元素
代码:
数组的静态初始化
指定数组的元素,长度由系统给定
原始格式:
数据类型[] 数组名称 = new 数据类型[]{元素1,元素2,元素3....} ;
简写方式:
数据类型[] 数组名称= {元素1,元素2,元素3..} ;举例:
int[] arr = new int[]{1,2,3} ;
int[] arr = {1,2,3} ;
int[] arr = new int[]{21,432,543,764};
注意！！！
这种方式错误:动静结合。定义数组要么动态初始化,指定长度,要么静态初始化,指定数组元素。
int[] arr2 = new int[3]{1,2,3} ;
代码:
数组中经常会出现的异常:
ArrayIndexOutOfBoundsException:数组角标越界异常
出现的原因:访问了数组中不存在的索引值;
解决方案:观察数组中到底有索引值到多少; 数组长度-1
NullPointerException:空指针异常 (在实际开发中该异常是最多的)
出现的原因:对象为null,而开发者还要去使用对象,就会出现问题
解决方案:给某个对象进行非空判断。
OOM异常:OutOfMemory:内存溢出 Android 解决加载大量图片的问题:图片加载器:ImageLoader等等防止程序空 指针异常
对于异常:
1)将从头到尾遇见的异常建立文档；
2)出现该异常的原因;
3)如何解决异常;
Test代码:
1)
package org.westos.array;
/**
* 数组中的应用:
* 给定一个数组,静态初始化的,遍历这个数组;
* @author Administrator
*
*/
public class ArrayTest {
public static void main(String[] args) {
//定义数组,静态初始化
int[] arr = {11,22,33,44,55} ;
/**
* 获取数组中的元素值,通过数组名称[索引]获取
*/
System.out.println(arr[0]);
System.out.println(arr[1]);
System.out.println(arr[2]);
System.out.println(arr[3]);
System.out.println(arr[4]);
System.out.println("----------------------");
//遇见这种重复性高的代码,可以采用for循环 :循环的思想
for(int x = 0 ; x < 5 ; x ++) {
System.out.println(arr[x]);
}
System.out.println("----------------------");
int[] arr2 = {11,22,33,44,56,78,23,10,20,30} ;
//如果数组中的元素非常多,元素个数非常麻烦
/**
* 针对这种情况,Java提供数组的属性:lenth属性
* 获取数组中的长度
*/
System.out.println(arr.length);
System.out.println(arr2.length);
System.out.println("----------------------");
//将上述代码继续改进,使用数组的长度进行操作
for(int x = 0 ;x < arr.length ; x ++) {
System.out.println(arr[x]);
}
//继续改进:学习方法,所以将遍历的功能写成一个独立的代码块
//调用
printArray(arr2);
System.out.println("------------------------");
printArray(arr) ;
System.out.println("------------------------");
//遍历数组之后:[11, 22, 33, 44, 55]
printArray2(arr);
printArray2(arr2);
}
/**
* 定义方法:两个明确
* 1)返回值类型: 没有具体返回值:void
* 2)参数类型:int类型数组
*
*/
public static void printArray(int[] arr) {
for(int x = 0 ; x < arr.length ; x ++) {
System.out.println(arr[x]);
}
}
//最终改进:
public static void printArray2(int[] arr) {
//左中括号
System.out.print("[");
for(int x = 0 ; x < arr.length ; x ++) {
//判断当前x是否是最后一个索引
if(x==arr.length-1) {//如果是最后一个索引
System.out.println(arr[x]+"]");
}else {
System.out.print(arr[x]+", ");
}
}
}
}
2)
package org.westos.array;
/**
* 数组中的最值应用:
* 自定义一个数组,静态初始化,求数组中的最大值或者最小值;
*
* 分析: 最大值:
* 1)定义一个数组,静态初始化
* 2)定义一个参照物,分别和数组中的其他元素进行比较,如果后面的元素都大于参照物,将后面作为参照物作为最大值
* 3)输出
* @author Administrator
*
*/
public class ArrayTest2 {
public static void main(String[] args) {
//定义一个数组
int[] arr = {13,98,24,30,10} ;
//定一个参照物,假设参照物就是最大值
int max = arr[0] ;
//从1开始遍历其他元素
for(int x = 1 ; x < arr.length ; x ++) {
//获取每一个元素
//依次和参照物进行比较,如果后面的元素都大于参照物,将后面作为参照物作为最大值
if( arr[x] > max) {
//将arr[x]赋值给max
max = arr[x] ;
}
}
//输出
System.out.println("最大值是:"+max);
System.out.println("------------------------------");
int max2 = max(arr) ;
System.out.println("最大值是:"+max2);
}
/**
* 定一个方法
* 两个明确:
* 1)明确返回值类型: int类型
* 2)明确参数类型:int[] arr
*/
public static int max(int[] arr) {
//定义参照物
int max = arr[0] ;
//遍历其他元素
for(int x = 1 ; x < arr.length ; x ++) {
//获取到每一个元素,分别和参照物进行比较,如果大了,就作为最大值进行继续比较
if(arr[x] > max) {
max = arr[x] ;
}
}
return max ;
}
}
3)
package org.westos.array;
/**
* 定义一个数组,元素逆序
*
* 分析:
* 定义一个数组,静态初始化
* 将数组中0索引对应的元素和arr.length-1索引对应的元素进行互换
* 将1索引对应的元素和arr.length-1-1索引对应的元素进行互换
* ....
* 只要保证数组的长度arr.length/2
* @author Administrator
*
*/
public class ArrayTest3 {
public static void main(String[] args) {
//定义一个数组,静态初始化
int[] arr = {12,98,50,76,24,78} ;//78 24 76 50 98 12
System.out.println("遍历前:");
printArray(arr);
System.out.println("------------------");
System.out.println("逆序后:");
// reverse(arr);
revers2(arr);
printArray(arr);
}
/**
* 逆序的方法
* 1)明确:明确返回值类型 void
* 2)明确参数类型:int[] arr
* @param arr
*/
public static void reverse(int[] arr)
//使用中间的方式进行互换
//第一次交换
// int temp = arr[0] ;
// arr[0] = arr[arr.length-1-0] ;
// arr[arr.length-1-0] = temp ;
//
// //第二次互换
// temp = arr[1] ;
// arr[1] = arr[arr.length-1-1] ;
// arr[arr.length-1-1] = temp ;
//
// //第三次
// temp = arr[2] ;
// arr[2] = arr[arr.length-1-2] ;
// arr[arr.length-1-2] = temp ;
//第四次
//....
for(int x = 0 ; x < arr.length/2 ; x ++) {
int temp = arr[x] ;
arr[x] = arr[arr.length-1-x] ;
arr[arr.length-1-x] = temp ;
}
}
//方式2;
public static void revers2(int[] arr) {
for(int start = 0,end = arr.length-1 ; start<=end ;start++,end --) {
//temp中间变量
int temp = arr[start] ;
arr[start] = arr[end] ;
arr[end] = temp ;
}
}
//遍历数组的方法
public static void printArray(int[] arr) {
System.out.print("[");
for(int x = 0 ; x < arr.length ; x ++) {
//是否是最后索引对应的元素
if(x==arr.length -1) {
System.out.println(arr[x] +"]");
}else {
System.out.print(arr[x] +", ");
}
}
}
}
4)
package org.westos.array;
import java.util.Scanner;
/**
* 数组中的元素基本查找法: ----->数值中的元素的查找,查找的是该元素在数组中的索引
*
* 有一个字符串数组
* String[] str = {"星期一","星期二","星期三","星期四","星期五","星期六","星期天"} ;
*
* 键盘录入一个数据,查找值对应星期几..
*
* @author Administrator
*
*/
public class ArrayTest4 {
public static void main(String[] args) {
// int a ;//必须初始化,(在使用之前)
//定义一个字符串数组
String[] str = {"星期一","星期二","星期三","星期四","星期五","星期六","星期天"} ;
//创建键盘录入对象
Scanner sc = new Scanner(System.in) ;
//接收数据
System.out.println("请输入一个数据:(0-6):");
int index = sc.nextInt() ;
System.out.println("你要查找的是:"+str[index]);
}
}
5)
package org.westos.array;
/**
* 数组中的元素查找法(数组中的基本查找法)
* 定义一个数组,静态初始化,查找某个元素在该数组中第一次出现的索引
*
* 分析:
* 1)给出了数组
* 2)写一个查找数组中的元素的索引的方法
* @author Administrator
*
*/
public class ArrayTest5 {
public static void main(String[] args) {
//定义一个数组:
int[] arr = {200,250,38,101,300} ;
//需求1:查找250这个元素在数组中第一次出现的索引
int index = findIndex(arr, 250) ;
System.out.println("250元素在数组中第一次出现的索引是:"+index);
// //需求2:查找2500这个元素在数组中第一次出现的索引
int index2 = findIndex(arr, 2500) ;
System.out.println("2500元素在数组中第一次出现的索引是:"+index2);
int index3 = getIndex(arr, 38) ;
System.out.println("index3:"+index3);
int index4 = getIndex(arr, 380) ;
System.out.println("index4:"+index4);
}
/**
* 定义一个查找数组中元素的方法
* 两个明确
* 1)返回值类型:int
* 2)参数类型:int [] arr ,两个参数, 第二个参数:int value
*/
public static int findIndex(int[] arr,int value) {
//遍历arr数组元素
for(int x = 0 ; x < arr.length ; x ++) {
//判断:如果查找的元素恰好就是value值,那么直接返回该索引
if(arr[x] == value) {
return x ;
}
}
//不但要考虑找到的情况,还要考虑到找不到的情况
//在Java中,数组查找元素,如果找不到,返回-1 ,(找不到)
return - 1;
}
//方式2,假设法
public static int getIndex(int[] arr,int value) {
//如果没有找到这个元素,假设找不到
int index = -1 ;
//遍历数组
for(int x = 0 ; x < arr.length ; x ++) {
//获取到每一个元素,如果找到,修改索引值
if(arr[x] == value) {
//修改
index = x ;
break ;
}
}
return index ;
}
}
二维数组
二维数组的声明与实例化：
定义:
1)数据类型[][] 数组名=new 数据类型[行的个数][列的个数];
2)数据类型 数组名[][] = new 数据类型[m][n]
3)数据类型[] 数组名[[] = new 数据类型[m][n]
访问二维数组元素的语法为：数组名[行的索引][列的索引];
初始化:
1)静态初始化
数据类型[][] 数组名称 = {{元素1,元素2,元素3},{....}} ;
代码实例:
public class ArrayDemo3 {
public static void main(String[] args) {
//定义一个二维数组,静态初始化
int[][] arr = {{1,2,3},{4,5},{6}} ;
System.out.println(arr);
System.out.println(arr[0][1]);
System.out.println(arr[1][1]);
System.out.println(arr[2][0]);
}
}
2)动态初始化
数据类型[][] 数组名 = new 数据类型[m][] ;
只给定m个一维数组,每一个一维数组的长度由动态给定
代码实例:
package org.westos.array;
/**
* 二维数组定义的第二种格式:
*
* 数据类型[][] 数组名 = new 数据类型[m][] ;
* 只给定有m个一维数组,每一个一维数组长度动态给定
* @author Administrator
*
*/
public class ArrayDemo2 {
public static void main(String[] args) {
//定义一个二维数组
int[][] arr = new int[3][] ;
System.out.println(arr);
//动态给定每一个一维数组的长度
arr[0] = new int[2] ;
arr[1] = new int[3] ;
arr[2] = new int[2] ;
System.out.println(arr[0]);
System.out.println(arr[1]);
System.out.println(arr[2]);
System.out.println(arr[0][1]);
System.out.println(arr[2][0]);
//赋值
arr[0][1] = 100 ;
arr[2][1] = 200 ;
System.out.println(arr[0][1]);
System.out.println(arr[2][1]);
}
}
获取二维数组的行数: 数组名.length;
获取二维数组的列数: 首先要确定是哪一行，因为二维数组每一行的元素个数不一定相同，再利用数组名[行的索引].length;
代码测试
package org.westos.array;
/**
* 关于二维数组的遍历
*
* 给定一个二维数组,静态初始化,遍历其中每个元素
* @author Administrator
*
*/
public class ArrayTest {
public static void main(String[] args) {
//定义一个二维数组,静态初始化
int[][] arr = {{1,2,3},{4,5,6},{7,8,9}};
//谁代表{1,2,3}
for(int x = 0 ; x < arr[0].length ; x ++) {
System.out.println(arr[0][x]);
}
System.out.println("---------------------");
//{4,5,6}
for(int x = 0 ; x < arr[1].length ; x ++) {
System.out.println(arr[1][x]);
}
System.out.println("---------------------");
for(int x = 0 ; x < arr[2].length ; x ++) {
System.out.println(arr[2][x]);
}
System.out.println("----------------------------");
//改进:通过外循环,arr.length :外层循环是二维数组的长度
for(int x = 0 ; x < arr.length ; x ++) {
for(int y = 0 ; y < arr[x].length; y++) {
System.out.print(arr[x][y]+" ");
}
}
System.out.println("----------------------------");
//最终版代码:定义一个遍历二维数组的功能
printArray2(arr);
}
/**
* 两个明确:
* 1)明确返回值类型:void
* 2)明确参数类型:int[][] arr
*/
public static void printArray2(int[][] arr) {
for(int x = 0 ; x < arr.length ; x ++) {
for(int y = 0 ; y < arr[x].length ; y++) {
System.err.print(arr[x][y]+" ");
}
}
}
}