Day05-数组的应用

Posted 2023-05-30 文姬公主

数组的应用

增强型的for循环

• 快捷键：array.for---->for(int array:arrays)

冒泡排序

• 思路

  1. 比较数组中两个相邻的元素，如果第一个数比第二个数大，我们就交换他们的位置

  2. 每一次比较都会产生出一个最大或者最小的数字

  3. 下一轮则可以少一次排序

  4. 依次循环直到结束

import javax.sql.rowset.FilteredRowSet;
import javax.swing.text.AbstractDocument;
import java.text.BreakIterator;
import java.time.temporal.Temporal;
import java.util.Arrays;
import java.util.concurrent.ForkJoinPool;
​
public class Demo01
​
    public static void main(String[] args) 
        int[] a=124,245,1,3,5,24,34;
        int[] bubble = bubble(a);
        System.out.println(Arrays.toString(bubble));
    
​
    //冒泡排序
    //1.比较数组中两个相邻的元素，如果第一个数比第二个数大，我们就交换他们的位置
    //2.每一次比较都会产生出一个最大或者最小的数字
    //3.下一轮则可以少一次排序
    //4.依次循环直到结束
    public static int[] bubble(int[] a)
        int temp=0;
        boolean flag=false;
        for (int i = 0; i < a.length-1; i++) 
            for (int j = a.length-1;j>i; j--) 
                if (a[j]<a[j-1])
                    temp=a[j];
                    a[j]=a[j-1];
                    a[j-1]=temp;
                    flag=true;
                
            
            if (flag==false)  //当所有元素都按序排列时，直接停止循环，减少时间
                break;
            
        
        return a;
    
​

稀疏数组

• 什么是稀疏数组？

  稀疏数组可以看做是普通数组的压缩，但是这里说的普通数组是指无效数据量远大于有效数据量的数组

  

• 稀疏数组的存储规则

  第0行保持原本二维数组的基本信息：即行数、列数、有效值的个数

  从第1行开始，就记录着每个值的行下标、列下标、有效值的值

import java.util.Arrays;
import java.util.Formattable;
​
public class Demo02 
    public static void main(String[] args) 
        //稀疏数组
        /**
         * 1.创建一个二维数组 11*11 0:没有棋子，1:黑棋，2:白棋
         */
        int[][] a = new int[11][11];
        a[1][2] = 1;
        a[2][10] = 2;
        System.out.println("输出原始的数组");
        for (int[] ints : a) 
            for (int anInt : ints) 
                System.out.print(anInt + "\\t");
            
            System.out.println();
        
​
        //转为稀疏数组保存
        //获取有效值的个数
        int sum = 0;
        for (int i = 0; i < a.length; i++) 
            for (int j = 0; j < a[i].length; j++) 
                if (a[i][j] != 0) 
                    sum = sum + 1;
                
            
        
        System.out.println("有效值的个数为：" + sum);
​
        //创建一个稀疏数组
        int[][] b = new int[sum + 1][3];
        b[0][0] = 11;
        b[0][1] = 11;
        b[0][2] = sum;
​
        //遍历二维数组，将非零的值存放到稀疏数组里面
        int count = 0;
        for (int i = 0; i < a.length; i++) 
            for (int j = 0; j < a[i].length; j++) 
                if (a[i][j] != 0) 
                    count++;
                    b[count][0] = i;
                    b[count][1] = j;
                    b[count][2] = a[i][j];
                
            
        
​
        System.out.println("稀疏数组");
        for (int i = 0; i < b.length; i++) 
            System.out.println(b[i][0] + "\\t" + b[i][1] + "\\t" + b[i][2]);
        
​
        System.out.println("还原");
        //1.读取稀疏数组
        int[][] c = new int[b[0][0]][b[0][1]];
​
        //2.给其中的元素还原它的值
        for (int i = 1; i < b.length; i++) 
                c[b[i][0]][b[i][1]] = b[i][2];
        
​
        //3.打印还原后的数组
        System.out.println("输出还原后的数组");
        for (int i = 0; i <c.length ; i++) 
            for (int j = 0; j <c[i].length ; j++) 
                System.out.print(c[i][j]+"\\t");
            
            System.out.println();
​
        
    

Java Day 06

二维数组
 定义：
 格式1 int[][] arr = new int[3][2];
 格式2 int[][] arr = new int[3][];//每个一维数组初始化时为null

空指针异常

格式3 int[][] arr ={{ },{ },{ }};
 
应用场景
 数组的数组
 map集合

面向对象
 
类与对象的关系
 类：事物的描述
 对象：类的实例
 属性和行为
 
 定义类就是在定义类中的成员
 成员变量 <--> 属性
 成员函数 <--> 行为

对象的内存体现
 栈 主函数 对象变量
 堆 创建对象实例

成员变量与局部变量区别
 1、成员变量定义在类中，整个类中可以访问
    局部变量定义在函数、语句、局部代码块中，只在所属区有效
 2、成员变量存在于堆内存的对象中
    局部变量存在于栈内存的方法中
 3、生命周期不同
 4、成员变量有默认初始化值，局部变量则没有

成员变量与局部变量同名
  方法进栈

匿名对象
 new Car();
 1、方法只调用一次，简化为匿名对象
 2、作为实际参数进行传递

参数传递是基本数据类型

 1 class Demo{
 2     public static void main(String[] args){
 3         int x=3;
 4         show(x);
 5         System.out.println("x="+x);
 6     }
 7     public static void show(int x){
 8         x=4;
 9     }
10 }

 

参数传递是引用数据类型

 1 class Demo{
 2     static int x=3;
 3     public static void main(String[] args){
 4         Demo d = new Demo();
 5         show(d);
 6         System.out.println("x="+x);
 7     
 8     }
 9     public static void show(Demo d){
10         d.x=9;
11     }
12 }

 

封装 隐藏对象的属性和实现细节，对外提供公共访问方式
private 对本类可见