小白学习Java第五天

sjxxxx_

已于 2022-08-09 17:35:49 修改

阅读量112

点赞数 1

分类专栏： Java小白文章标签： java 学习数据结构

于 2022-08-01 20:06:33 首次发布

本文链接：https://blog.csdn.net/sjxxxx_/article/details/126108496

版权

Java小白专栏收录该内容

60 篇文章 4 订阅

订阅专栏

第五天
复习：

循环嵌套
外循环是行，内循环是列
跳转语句
break：循环或switch
continue: 循环
return: 方法
方法
定义在类中，与main平级，只有void（空）可以省略return，且无法在打印语句中使用。
返回值类型只能大于等于return后的返回值类型。

目标：

数组理解
数组创建
数组内存理解
数组应用

一.数组理解
概念：是一个容器，可以存储多个数据。

特点：

存储的数据必须是相同类型
容器的大小是固定的
数组存储的每一个数据都有下标，通过下标操作数据，下标从0开始
获取数组长度；数组名.length
获取最大下标值：数组名.length-1
容器中既可以存储基本类型数据，也可以存储引用类型数据

二. 数组创建（[]的位置不是固定的）=

动态定义：

元素类型[] 数组名 = new 元素类型[元素个数]；
数组名[] = 元素1；
数组名[] = 元素2；
…

静态定义：

元素类型[] 数组名 = new 元素类型[]{元素1，元素2，元素3，…}；
简写（不能拆开写）：
元素类型[] 数组名 ={元素1，元素2，元素3，…}；

public class Demo2{
	public static void main(String[] args){
		//动态定义：
		//格式：元素类型[]  数组名 = new 元素类型[元素个数];
		//创建一个数组容器，存储的数据的数据类型是int，存储3个，容器名是arr
		int[] arr =  new int[3];
//		int arr[] =  new int[3];
		//存数据，通过下标
		arr[0] = 98;
		arr[1] = 100;
		arr[2] = 123;

		//取数据，通过下标
		int x = arr[0];
		System.out.println("x = " + x);
		

		//静态定义：
		//元素类型[]  数组名 = new 元素类型[]{元素1,元素2,元素3,....};
		int[]  arr1 ;
		arr1 = new int[]{1,2,3,4,5};

		//取出并打印
		System.out.println(arr1[0]);
		//修改
		arr1[2] = 99;
		System.out.println(arr1[2]);

		//简写格式
		int[] arr2 = {2,3,4,5};
		System.out.println(arr2[3]);




		System.out.println("Hello World!");
	}
}

public class Demo3{
	public static void main(String[] args){
		int[]  arr = {1,2,3,4,4,5};

		//遍历数组元素，即输出打印每个元素
		for(int i = 0; i < arr.length; i++){
			System.out.println("arr["+i+"] = "+arr[i]);
		}

		//练习：输出数组元素，格式：{1,2,3,4,4,5}
//		System.out.print("{");
//		for(int i = 0; i < arr.length; i++){
//			if(i != arr.length-1)
//				System.out.print(arr[i]+",");
//			else
//				System.out.print(arr[i]);
//		}
//		System.out.print("}");

		String s = "";
		for(int i = 0; i < arr.length; i++){
			if(i != arr.length-1){
				s = s + arr[i]+",";
			}else{
				s = s + arr[i]+"}";
			}
		}

		System.out.println(s);



		System.out.println("Hello World!");
	}
}

三. 数组内存理解（数组是引用类型）

1.Jvm启动时，将内存划分了5块区域，不同区域做不同的管理，提高效率
有关：堆，栈，方法区；无关：寄存器，本地方法区
2.栈：用来执行方法（不调用不进栈）
特点：先进的后出
局部变量：都有作用域，存储在栈中
3.堆：用来存储容器中的数据

1). 只要看见关键字new，说明都是在堆中开辟空间

2). 开辟空间就要占位置，分配内存地址

3). 在该空间中存储默认值

整数：0； float:0.0f； double:0.0； boolean:false； char:’\u0000’
引用：null
4. 堆中的容器没有被任何引用变量所指向，那么这个容器就是无用的
在java中有一个GC机制会不定时启动，处理堆中的无用容器，（c需要手动处理）
如何让容器成为无用：引用变量值 = null
5. 方法的传递是参数传递类型：
1).值传递：指的是基本数据类型，对原来的变量没有影响
2).引用传递：指的是引用数据类型值（地址值）的传递，对原来变量有影响
6.操作数组容易出现的两个异常：
1).ArrayIndexOutOfBoundsException:是数组下标越界异常，操作了不存在的下标值
2).NullPointerException:是空指针异常，当程序试图在需要对象的地方使用null时

public class Demo7{
	public static void main(String[] args){
		int[] arr = {1,2,3};
		//System.out.println(arr[3]); //越界异常

		arr = null; // arr 和容器间没有指向关系了
		System.out.println(arr[0]);  //空指针异常
	}
}

[I@15db9742 : 
[ : 代表是数组，个数决定了是几维数组
I ：大写i 数组中储存的数据的数据类型（或简写）
@：字符符号，占位符，拼接作用，无实际意义
15db9742 : 十六进制数据(0x在开头出现就代表16进制数)，哈希码值
		默认不同的容器哈希码值不同

public class Demo4{
	public static void main(String[] args){
		//创建一个数组
		int[] arr = new int[3];
		System.out.println(arr);
		System.out.println(arr[0]); //0
		/*
		[I@15db9742
		  [ : 代表是数组，个数绝对了是几维数组。一维数组
		  I : 数组中存储的数据的数据类型的简写
		  @ : 字符符号，占位符，用来做拼接的没啥实际意义
		15db9742 :十六进制数据，哈希码值
		          默认不同的容器哈希码值不相同
		*/

		int[] arr1 = arr; //将arr的值赋值给arr1
		                  //两个引用指向同一个容器

		arr[0] = 99;
		System.out.println(arr1[0]);//99

		int[] arr2 = new int[3];
		System.out.println(arr2[0]); //0

		
//		String[] arr1 = new String[2];
//		System.out.println(arr1);
//		System.out.println(arr1[0]);
	}

	

}

四.数组的应用
遍历数组的元素，寻找最值，是否包含指定数值，反转数组

public class Demo5{
	public static void main(String[] args){
		int[] arr = {2,6,4,90,9,7,78};  
//		int max = getMax(arr);
//		System.out.println("最大值是："+max);

//		int min = getMin(arr);
//		System.out.println("最小值是："+min);

//		int index = findArray(arr, -7);
//		System.out.println("index = " + index);

//		int a = 10, b = 20;
//		int temp = a;
//		a = b;
//		b = temp;

		arr = reverse(arr);
		printArray(arr);

	}
	
	//反转数组元素，即首尾交换
	public static int[] reverse(int[] arr){
		for(int i = 0; i < arr.length/2; i++){
			int temp = arr[i];
			arr[i] =arr[arr.length-1-i];
			arr[arr.length-1-i]=temp;
		}

		return arr;
	}

//	public static void  reverse(int[] arr){
//		//反转
//		for(int i = 0; i < arr.length/2; i++){
//			int temp = arr[i];
//			arr[i] =arr[arr.length-1-i];
//			arr[arr.length-1-i]=temp;
//		}
//		//遍历数组
//		printArray(arr);
//	}

	public static void  printArray(int[] arr){
		for(int i = 0; i < arr.length; i++){
			System.out.print(arr[i]+"  ");
		}

		System.out.println();//回车
	}




	//封装方法，查找数组中是否包含指定的数据，包含返回对应的下标，不包含返回常量值-1.
	public  static  int  findArray(int[] arr, int key){
		for(int i = 0; i < arr.length; i++){
			if(arr[i] == key){
				return i;
			}
		}
		return -1;
	}


	//获取数组元素的最值问题
	public static  int  getMax(int[] arr1){ //arr1 = arr  引用传递(两个引用指向的是同一个数组容器)
		int max = arr1[0]; //默认第一个数组最大
		for(int i = 1; i < arr1.length; i++){
			if(max < arr1[i])
				max = arr1[i];
		}

		return max;

	}

	public static  int  getMin(int[] arr1){ //arr1 = arr  引用传递(两个引用指向的是同一个数组容器)
		int min = arr1[0]; //默认第一个数组最小
		for(int i = 1; i < arr1.length; i++){
			if(min > arr1[i])
				min = arr1[i];
		}

		return min;

	}

}

public class Demo6{
	public static void main(String[] args){
//		int a = 10;
//		test(a);
//		System.out.println("a = " +a);//10
	
		int[] array = {1,2,3};
		test1(array);
		System.out.println(array[0]); // 100
	}


	public static  void  test1(int[] arr){ //arr = array,两个引用指向同一容器
		arr[0] = 100;
	}

	public static  void  test(int b){ //b=a，不影响原值
		b = 100;
	}

}

二维数组

public class Demo7 {
    public static void main(String[] args) {
        //定义二维数组
        int[][] arr = {{1,2,3},{4,5,6,7},{8,9,0}};

        //遍历二维数组
        //求和  求平均值
        int sum = 0; //和
        int  count = 0; //计数器
        for(int i = 0; i < arr.length; i++){ //行
            for(int j = 0 ;j < arr[i].length; j++){  //列
                System.out.print(arr[i][j]+"  ");
                sum = sum + arr[i][j];
                count++;
            }
        }

        System.out.println("\nsum = " + sum);
        System.out.println("avg = " + (sum/count));

        //for-each实现遍历
        for(int[] a:arr){
            for( int  b : a){
                System.out.println(b);
            }
        }


//        for (int i = 0; i < arr.length; i++){
//            System.out.println(arr[i]);
//        }
//
//        for (int j = 0; j < arr[0].length; j++){
//            System.out.println(arr[0][j]);
//        }
       /* System.out.println(arr[0][0]);
        System.out.println(arr[0][1]);
        System.out.println(arr[0][2]);

        System.out.println(arr[1][0]);
        System.out.println(arr[1][1]);
        System.out.println(arr[1][2]);
        System.out.println(arr[1][3]);*/
    }
}

```java