数组
1.1什么是数组
JavaSE 中容器:
容器:就是能够存储很多数据
数组是一个容器,能够存储同一种类型元素的容器!
1.2数组如何定义
格式
数据类型[] 变量名称 ;
数据类型 变量名称[] ;
举例:
int[] arr ; 定义了一个int数组的arr变量 (推荐这个格式)
int arr[] ; 定义一个int类型的arr数组
1.3数组如何初始化
1.3.1动态初始化
动态初始化: 给定数组的长度,元素由系统默认初始化!
格式:
数据类型[] 数组名称 = new 数据类型[长度] ; (推荐)
数据类型 数组名称[] = new 数据类型[长度] ;
举例: int[] arr = new int[3] ;
引用类型:一旦对象创建了,地址值永远固定,除非重新new 新的对象,才产生一个新的地址!
**数组名称[索引值] **访问数组的元素
public class ArrayDemo {
public static void main(String[] args){
//按照上面的写法:
//数据类型[] 数组名称 = new 数据类型[长度] ; (推荐)
int[] arr = new int[3] ;
/**
* =号左边
* int:现在数组是int类型
* []:表示一维数组
* arr :数组对象名称
*
*
* =号右边
* new :创建对象(堆内存中)
* int:创建的是int类型数组
* []:一维数组
* 3:表示指定数组的长度
*
* */
System.out.println(arr);//[I@1540e19d :理解为 对象在内存中的地址值!
//[:表示一维数组
//I:int :int数组
//@:地址值的标记
//1540e19d:十六进制数据
//如何确定数组的元素呢
//数组名称[索引值]访问数组的元素: 索引值:0开始
System.out.println(arr[0]) ; //第一个元素
System.out.println(arr[1]) ; //第二个个元素
System.out.println(arr[2]) ; //第三个元素
System.out.println("---------------------") ;
arr[0] = 20 ;
arr[1] = 10 ;
arr[2] = 30 ;
System.out.println(arr);
System.out.println(arr[0]) ; //第一个元素
System.out.println(arr[1]) ; //第二个个元素
System.out.println(arr[2]) ; //第三个元素
System.out.println("-----------------------") ;
/* arr = new int[2] ;
System.out.println(arr) ;*/
}
}
1.3.2静态初始化
第二种初始化:静态初始化
指定具体元素的内容,系统默认分配长度!
1.3.2.1格式
静态标准格式:
数据类型[] 数组名称 = new 数据类型[]{元素1,元素2,元素3.....} ;
数据类型 数组名称[] = new 数据类型[]{元素1,元素2,元素3....} ;
简写格式
数据类型[] 数组名称 = {元素1,元素2,元素3.....} ; (推荐)
数据类型 数组名称[] = {元素1,元素2,元素3.....} ;
注意事项:
//int[] arr = new int[5]{11,22,33,44,55} ;
//错误的:数组初始化只能有一种:不能既动态初始化,又静态初始化
1.4常见的两个问题
1.数组:---数组角标越界异常:
ArrayInddexOutOfBoundsException :程序运行时出错---- 运行时期异常
出现错误的原因:
开发者在书写代码的时候导致,角标值超出了数组的长度
解决方案: 只要正常访问角标值就可以
2.引用类型-----出现空指针异常
NullPointerException: 程序运行时出错---运行时期异常
出现的原因:
某个对象(数组)已经为null了,堆内存中没有空间地址值了,开发者还试图访问这个对象(数组)中的元素,就会有问题
解决方案:
针对对象:进行逻辑判断
如果对象不为null,再去访问;
1.5数组的遍历
public class ArrayTest {
public static void main(String[] args) {
int[] arr = {12, 23, 34, 45, 56, 67, 78, 89};//静态初始化一个数组
//遍历
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(arr[5]);
System.out.println(arr[6]);
System.out.println(arr[7]);
System.out.println("------------------------");
//用循环遍历
System.out.print("[");
for (int x = 0; x < arr.length; x++) { //数组名称.length:数组的长度
if (x == arr.length - 1) {
System.out.println(arr[x] + "]"); //输出最后一个元素
} else {
System.out.print(arr[x] + ", ");//输出中间元素
}
}
}
}
1.6数组逆序
public class ArrayTest4 {
public static void main(String[] args) {
int[]arr = {12,87,69,24,65};
System.out.println("逆序前");
printArray(arr);//调用遍历方法
revers2(arr);//调用逆序方法
System.out.println("逆序后:");
printArray(arr);//再次遍历
}
//定义逆序的方法
//1)明确返回值类型:void没有具体返回值
//2)明确参数类型及参数个数:int类型的数组,1个参数.
public static void revers(int[] arr){
for(int x=0;x<arr.length/2;x++){
int temp=arr[x];
arr[x]=arr[arr.length-1];
arr[arr.length-1]=temp;
}
}
//再定义一个逆序的方法
public static void revers2(int[] arr){
for(int start = 0, end = arr.length-1;start<end;start++,end--){
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[arr.length-1]+"]");
}
else{
System.out.print(arr[x]+", ");
}
}
}
}
1.7基本元素查找法
查询一个数组中某个元素第一次在数组中出现的索引值(不考虑重复)
import java.util.Scanner;
public class ArrayTest5 {
public static void main(String[] args){
int[]arr={12,23,34,45,56,67,78,89};
Scanner sc = new Scanner(System.in);
System.out.println("请输入要查询的元素:" );
int num = sc.nextInt();
int index = getIdex(arr,num); //调用查询方法
System.out.println("index:"+index);
}
//定义获取数组中元素角标值得方法
public static int getIdex(int[]arr,int key){
for(int x =0;x<arr.length;x++){
if (key==arr[x]){
return x;
}
}
return -1;
}
//方式2 假设思想
public static int getIndex2(int[] arr,int key){
int index=-1;
for(int x =0;x <arr.length;x++){
if (key==arr[x]){
index =x;
}
}
return index;
}
}
1.8冒泡排序
思想:
两两比较,第一次比较完毕,最大值出现在最大索引处
依次这样比较
规律:
两两比较,第一次比较完毕,最大值出现了
每次比较完毕,下一次减少比较
第一次:有0个不比
第二次,有1个不比
第三次,有2个不比
第三次,有3个不比
最终比较的次数:数组长度-1次
数组长度:arr.length
public class ArrayDemo {
public static void main(String[] args){
//已知一个数组
int[] arr = {24,69,87,57,13} ; //无序的数组
//调用方法来完成:排序
bubbleSort(arr);
//遍历
printArray(arr);
定义一个方法:专门来对数组进行冒泡排序的
* 两个明确
* 1)明确返回值类型: void (没有具体返回值类型)
* 2)明确参数类型以及参数个数
* int[] ,1个参数
public static void bubbleSort(int[] arr){
for(int x = 0 ; x < arr.length-1 ; x ++){//0,1,2,3 :循环的次数
for(int y = 0 ; y < arr.length-1-x;y++){
//判断:如果前面的元素比后面元素大,将大的元素往后方法
//交互元素----采用中间变量的方式
if(arr[y] > arr[y+1]){
int temp = arr[y] ;
arr[y] = arr[y+1] ;
arr[y+1] = 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]+", ") ;
}
}
}
1.9关于基本数据类型和引用数据类型(数组)作为形式参数的问题研究
基本数据类型作为形式参数传递有什么特点:
基本类型作为形式参数传递,形式参数的改变不会影响实际参数,实际参数是什么,它的值还是那个原来的数据!
引用数据类型作为形式参数传递有什么特点: (后期研究的肯定是引用类型)
引用类型(数组,类,接口) 作为形式参数传递,形式参数的改变会直接影响实际参数!
public class ArgsDemo {
public static void main(String[] args){
//定义两个变量
int a = 10 ;
int b = 20 ;
System.out.println("a:"+a) ;
System.out.println("b:"+b) ;
System.out.println("-----------------") ;
//调用change方法
change(a,b) ;
System.out.println("a:"+a) ;
System.out.println("b:"+b) ;
System.out.println("-----------------") ;
//创建一个数组
int[] arr = {1,2,3,4,5} ; //int[] arr = new int[]{1,2,3,4,5} ;
System.out.println(arr[1]) ; //2
change(arr) ;
System.out.println(arr[1]) ;
}
//重载的change方法
public static void change(int[] arr){
//遍历数组
for(int x =0 ; x < arr.length ; x ++){
if(arr[x] % 2 == 0){
arr[x] *= 2;
}
}
}
//change方法传递的是两个基本类型
public static void change(int a,int b){ //形式参数
System.out.println("a:"+a);
System.out.println("b:"+b) ;
System.out.println("===================================") ;
a = b ;
b = a+ b ;
System.out.println("a:"+a);
System.out.println("b:"+b) ;
}
}