Java数组

最新推荐文章于 2023-09-25 16:32:28 发布

Mr_muu

最新推荐文章于 2023-09-25 16:32:28 发布

阅读量136

点赞数 1

分类专栏： Java基本语法

本文链接：https://blog.csdn.net/Mr_muu/article/details/107719747

版权

Java基本语法专栏收录该内容

5 篇文章 0 订阅

订阅专栏

Demo，数组的简述。
/**
* 1.数组是什么？为什么使用数组？
* 比如我要统计每位员工的工资，我得定义多个变量去分开存储，因为一个变量只能保存一个数据，如果过多的员工，
* 太麻烦了，那么我怎么用一个变量去存储多个员工工资呢？
* 可以使用数组，数组就是一个大的容器，他可以存放多个值
* 2.什么是数组？
* 数组和变量差不多，都是存放数据的，不同的是变量只能保存一条数据，而数组可以保存多条数据，前提这个多条数据
* 必须是同一类型的
* 数组是引用数据类型
*
* 3.如何定义数组？
* 数组类型[] 数组名;
*
* 如果定义好数组以后，必须要给数组进行初始化。
* 数组是一个引用数据类型
* 数组的初始化分为两种情况：
* (1).动态初始化：指定数组的长度，一旦长度指定，就是数组中只能存放多少数组
* 两种格式：
* 第一种：
* 数组类型[] 数组名=new 数组类型[数组长度];
* 第二种方式：
* 数组类型[] 数组名;
* 数组名=new 数组类型[数组长度];
* (2)静态初始化：不是指定数组长度，而是直接在初始化数组的同时给数组赋值
* 两种：
* 第一种：
* 数组类型[] 数组名=new 数组类型[]{数据1，数据2.....};
* 第二种：
* 数组类型[] 数组名;
* 数组名=new 数组类型[]{数据1,数据2.。。。};
*
* 还有一种最简单的方式：
* 数组类型[] 数组名={数据1，数据2....};
*/

public class Demo {

    public static void main(String[] args) {
        
        //统计每位员工的工资 5位
//        int money=5000;//第一位
//        int money1=8000;//第二位
//        int money2=8000;//第二位
        
        //1.定义了一个数组，并进行动态初始化
        /**
         * int:数组类型是int类型的，也就代表我这个数组只能存放整数，而且只能存放9个整数
         * array：数组名
         */
        int[] array=new int[9];
        //2.动态初始化的第二种
        double[] array1;
        array1=new double[10];
        //创建好了数组，怎么给数组进行赋值。通过数组的下标，数组的下标从0开始
        array[0]=10;//给数组的第一个元素赋值
        array[1]=11;
//        array[8]="aaa"; 错误的
//        array[9]=20; 数组下标越界
        System.out.println(array[0]);
        
        //3.静态初始化第一种：
        int[] array2=new int[]{8,9,45,20,19};
        System.out.println(array2[3]);//20
        
        //4.静态初始化的第二种：
        int[] array3;
        array3=new int[]{67,89,90,1,34};
        System.out.println(array3[1]);//89
        
        //5,最简洁的方式创建数组
        int[] array4={12,3,4,6,2};
        System.out.println(array4[4]);//2
        
        //6.我想获取数组的长度    数组名.length，数组的长度一旦定义，不开改变
        System.out.println("array3数组的长度："+array3.length);
//        System.out.println(array3[5]=10);
        
        //7.数组中常见的几种异常
        //数组越界异常：ArrayIndexOutOfBoundsException
        int[] a=new int[2];
        //System.out.println(a[2]=10);//错误的
        
        //NullPointerException:空指针
        int[] b=null;
        System.out.println(b[0]);
        
        
        
    }

}

Demo2，遍历数组的方法

public class Demo2 {

    public static void main(String[] args) {
        int[] array=new int[]{12,4,6,34,90,89,12};
        //我想获取数组的每一个元素值
        System.out.println(array[0]);
        System.out.println(array[1]);
        //...
        //for使用循环  i代表的是数组的下标
        System.out.println("使用for循环遍历数组");
        for(int i=0;i<array.length;i++){
            System.out.println(array[i]);
        }
        
        //foreach(for循环的增强版)
        System.out.println("foreach遍历数组");
        /**
         * for(定义变量接受数组的每一个元素值：要遍历的数组名)
         * 数组遍历只有两种
         */
        for(int a:array){
            System.out.println(a);
        }
    }

}

Demo3，不同类型数组的初始化默认值
/**
* 数组分类
* 1.基本数据类型的数组
* 动态初始化数组以后，数组的元素都会赋予一个默认值
* byte short int long double float char boolean
* 0 0 0 0 0.0 0.0 空格 false
* 2.引用数据类型的数组
* String 接口自己定义类.....
* 引用数据类型的默认值为null
*/

public class Demo3 {

	public static void main(String[] args) {
		//int 类型的数组
		int[] num=new int[5];
		num[0]=10;
		num[3]=12;
		for(int n:num){
			System.out.println(n);
		}
	   //double类型
		double[] d=new double[2];
		System.out.println(d[0]);//0.0
		System.out.println("=======================");
		//char类型
		char[] c=new char[3];
//		System.out.println(c[0]);//空格
		for(int i=0;i<c.length;i++){
			System.out.println("-"+c[i]+"-");
		}
		//boolean
		boolean[] b=new boolean[5];
		System.out.println(b[2]);//false
		
		//String
		String[] str=new String[4];
		str[0]="张三";
		for(String s:str){
			System.out.println(s);
		}
		
		//数组类型是Student类型
		Student[] stu=new Student[1];
		stu[0]=new Student("张三",18);//创建了一个对象，并且给这个对象的属性赋值
		for(int i=0;i<stu.length;i++){
			System.out.println("姓名："+stu[i].getName()+",年龄："+stu[i].getAge());
		}
	}

}

Student类，定义了get和set方法。

//学生类  属性和行为
public class Student {
	private String name;//姓名
	private int age;//年龄
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	public Student(String name, int age) {
		super();
		this.name = name;
		this.age = age;
	}
	public Student() {
		super();
	}
}

Demo4，java中的内存分配

/**
* java中的内存是怎么进行分配的？
* 内存的申请和释放都是jvm进行管理的，java程序要运行，jvm会自动的向电脑申请一块内存，
* 把这块内存分为5部分：
* 1.栈(Stack):主要存放局部变量(重点)
* 2.堆(Heap):凡是new出来的东西都在堆里面，堆当中的数据都有默认原则：（重点）
* 整数 0 小数 0.0 布尔：false char:空格引用数据类型：null
* 3.方法区(Method Area):存放的是与.class相关的信息
* 4.本地方法区(Native Method Area):与操作系统有关
* 5.寄存器(Register):与cpu有关
*
* */

Demo5，数组计算总分、平均值、最高分、最低分、逆序输出

public class Demo5 {

	public static void main(String[] args) {
//		1.求出学生成绩的总分、平均分、最高分、最低分
		int[] score=new int[]{90,89,56,87,98};
		//总分
		int sum=0;
		for(int i=0;i<score.length;i++){
			sum+=score[i];
		}
		System.out.println("总分："+sum);
		//平均分
		int avg=sum/score.length;
		System.out.println("平均分："+avg);
		
		//最高分
		int max=score[0];
		for(int i=0;i<score.length;i++){
			if(max<score[i]){
				max=score[i];
			}
		}
		System.out.println("最高分："+max);
		
		//最低分
		int min=score[0];
		for(int i=0;i<score.length;i++){
			if(min>score[i]){
				min=score[i];
			}
		}
		System.out.println("最低分："+min);
//
//		2. {“C语言“,”C++“,”C#“,”Java“,”Python“,"js"}; 逆序输出。
		String[] str=new String[]{"C语言","C++","C#","Java","Python"};
		for(int i=0;i<str.length/2;i++){
			String temp=str[i];
			str[i]=str[str.length-1-i];
			str[str.length-1-i]=temp;
		}
		for(String s:str){
			System.out.println(s);
		}

	}

}

Demo6，冒泡排序（重点）

/**
* 冒泡排序（重点）
*
* 口诀(升序)
* n个数字来排队
* 两两相比小靠前
* 外层循环n-1
* 内层循环n-1-i
*
*/

public class Demo6 {

	public static void main(String[] args) {
		//从大到小
		int[] array={76,3,234,90,6,78,1,-1};
		
		//外层循环控制趟数
		for(int i=0;i<array.length-1;i++){
			//内层控制次数
			for(int j=0;j<array.length-i-1;j++){
				//比较  从大到小用<  小到大>
				if(array[j]<array[j+1]){
					int temp=array[j];
					array[j]=array[j+1];
					array[j+1]=temp;
				}
				
			}
		}
		for(int num:array){
			System.out.println(num);
		}

	}

}

Demo7，选择排序（了解）效率比较低

public class Demo7 {

	public static void main(String[] args) {
		
		int[] num={25,4,56,122,2};
		//使用选择排序实现小到大排列
		for(int i=0;i<num.length-1;i++){
			for(int j=i;j<num.length;j++){
				if(num[i]>num[j]){
					int temp=num[i];
					num[i]=num[j];
					num[j]=temp;
				}
			}
		}
		for(int n:num){
			System.out.println(n);
		}

	}

}

Demo8，二维数组

/**
* 二维数组：数组中的数组
* 1.声明二维数组：
* 数据类型[][] 数据名;
* 第一个中括号：二维数组中有几个一维数组行
* 第二个中括号：每个一维数组中有多少元素列
*
* 2.初始化二维数组
* 第一种动态初始化
* 第二种静态初始化
*/

public class Demo8 {

	public static void main(String[] args) {
		
		//1.创建一个二维数组，并动态初始化
		//5代表5行或者表示包含5个一维数组
		//7代表7列或者表示每个一维数组的长度是7
		int[][] array=new int[5][7];
		//2.如何赋值
		//第一个一维数组的第一个元素值为10
		array[0][0]=10;
		//第四个一维数组的第7个元素的值为5
		array[3][6]=5;
		
		System.out.println(array[0][0]);
		System.out.println(array[2][0]);
		
		//3.静态初始化
		int[][] array1=new int[][]{{1,2},{2,3,4},{5,9,89,1}};
		System.out.println(array1[2][2]);//89
		
		//简写
		int[][] array2={{4,90},{23,12},{12,23,45}};
		System.out.println("获取二维数组的长度："+array2.length);
		
		//4.遍历二维数组
		//外层循环控制行（每一个一维数组）
		for(int i=0;i<array2.length;i++){
			//内存循环控制的是列
			for(int j=0;j<array2[i].length;j++){
				System.out.print(array2[i][j]+" ");
			}
			System.out.println();
		}
		
		System.out.println("使用增强for循环=============");
		for(int[] i:array2){
			for(int a:i){
				System.out.print(a+" ");
			}
			System.out.println();
		}
		
	}

}

Demo9，双层循环遍历二维数组

public class Demo9 {

	public static void main(String[] args) {
//		在一个酒店中，一共有三层楼，每层有4个房间。
//		101 102 103
//		201 202 203  205
//		301 302 
//		楼层:使用数字1,2,3表示
//		房间号:使用101,102,103,104 表示……
//		要求:使用二维数组赋值并遍历输出。
		
		int[][] array=new int[][]{{101,102,103},{201,202,203,205},{301,302}};
		for(int i=0;i<array.length;i++){
			System.out.println("第"+(i+1)+"层：");
			for(int j=0;j<array[i].length;j++){
				System.out.print(array[i][j]+" ");
			}
			System.out.println();
		}

	}

}