Day10知识总结

JAVA数据结构

数组、List、Set
Map
自定义数据结构

程序=算法+数据结构

算法：(解决问题的步骤 顺序、分支、循环)
数据结构：(将数据按某种特定的结构保持)

数组

数组是引用数据类型、 最基本的数据结构
数组是相同数据类型的元素组成的集合

数组元素线性顺序排列：

[ 除第一个元素外，每一个元素都有唯一的前驱元素
除最后一个元素外，每一个元素都有唯一的后继元素 ]

数组创建初始化

数组在执行new语句才使数组分配到了指定大小空间

数组写法: int[] arr
数组中不能缺少[];

定义数组

int[] a1={1,2,3,4,5,6,7}; //方法一
int[] a2=new int[]{10,20,30};//方法二
int[] a3=new int[4];//方法三

//int[] a2=new int[]; //编译错误，未指定数组长度

int[] a2=new int[];
是不合法的，存在编译错误，由于未指定数组长度

先定义，再初始化

若先定义引用再赋值，就不能使用{}方式

int[] a4;
a4={1,2,3,4};
是不合法的，存在编译错误

先定义后赋值，只能使用new语句

int[] a4;
a4=new int[]{1,2,3,4};
//a4={1,2,3,4};
//编译错误，若先定义引用再赋值，就不能使用{}方式

数组默认值 不同数据类型默认值不同

不同数据类型的数组若未元素初始值，则元素默认值不同[在new之后]

int[ ] a1 —— 元素默认值为0
char[ ] a2 —— 元素默认值" " [空格]
String[ ] a3 —— 元素默认值为null [String引用数据类型]
double[ ] a4 —— 元素默认值为0.0
boolean[ ] a5 —— 元素默认值为false

int[] a4=new int[8]; //未元素初始值，元素默认值为0
char[] a5=new char[6]; //默认值为" "空格
String[] a6=new String[6]; //String引用数据类型 默认值 null
double[] a7=new double[6]; //默认值0.0
boolean[] a8=new boolean[6];//默认值false
System.out.println(Arrays.toString(a4)); //[0, 0, 0, 0, 0, 0, 0, 0]
System.out.println(Arrays.toString(a5)); //[ ,  ,  ,  ,  ,  ]
System.out.println(Arrays.toString(a6));//[null, null, null, null, null, null]
System.out.println(Arrays.toString(a7));//[0.0, 0.0, 0.0, 0.0, 0.0, 0.0]
System.out.println(Arrays.toString(a8));//[false, false, false, false, false, false]

数组复制

指定某个数组的某个位置开始，复制数据，把复制的数据放到另一个数组的某个位置，并设置需要复制的个数
System.arraycopy(src,srcPost,dest,destPost,length)

src：复制的原数组
srcPos：原数组复制的起始位置
dest：复制到的目标数组
destPost：复制到目标数组中的起始位置
length：复制的元素个数

返回值为空,无法返回值
功能:搬运元素
不未产生新的数组，主要修改数组中的元素

int[] arr={1,2,3,4,5,6,7,8,9,10};
int[] arr2=new int[6];
System.arraycopy(arr,3,arr2,0,6); //把4~9，复制给arr2;

//将arr的4,5,6,7复制到arr3中下标为3的地方
int[] arr3={1,2,3,0,0,0,0,0};
System.arraycopy(arr,3,arr3,3,4);  //{1,2,3,4,5,6,7,0}

数组扩容

数组的长度在创建后不可变，所谓扩展，即创建一个更大新数组，并将原有数组的内容复制到其中
Arrays.copyOf(原数组,扩展后的长度)

Arrays.copyOf(arr,arr.length+1)

分解质因数,把质因数存储再数组中，把质因子的平法和计算出来

由于不知道质因子个数，首先将数组定义为int[] arr=new int[0];
当每次找到一个质因子数后，对数组进行 [长度+1] 扩容，再将质因子放置最后一个位置。

   public static void simpleTest2(){
        Scanner scanner=new Scanner(System.in);
        System.out.println("输入一个数");
        int n=scanner.nextInt();
        int[] arr=new int[0]; 
        int n1=n;
        for (int i=2;i<=n;i++){
            if(n%i==0){  //找到一个质因数
                n=n/i;
                if(i==n1)
                    System.out.println(i+"是一个质数，无质因子");
                else {   
                    arr=Arrays.copyOf(arr,arr.length+1);  //数组扩容
                    arr[arr.length-1]=i;  //将质因数的值放置最后一位
                }
                i--;
            }
        }
        int sum=0;
        if(arr.length>0){
            for(int i=0;i<arr.length;i++)
                sum+=Math.pow(arr[i],2);
            System.out.println(n1+"质因数有"+Arrays.toString(arr));
            System.out.println("该数的质因数平方和为"+sum);
        }
    }

数组排序

Arrays.sort() ，JDK提供排序方法 升序排序[从小到大]
sort方法无法返回值,无新数组产生,修改原数组数据顺序

数值型数组排序

int[] arr={19,78,44,47,89,34,78,97,85,47};
Arrays.sort(arr); //[19, 34, 44, 47, 47, 78, 78, 85, 89, 97]

字符串数组排序

按单词首字母的编码排序,若字母相同，就比较第二个…
默认升序排序

String[] strs= {"tom","jack","jerry","rose","hanmeimei","小红"};
 Arrays.sort(strs);  //[hanmeimei, jack, jerry, rose, tom, 小红]

知识

char数组转化为int数值

对于字符型数字例如 ‘0’、‘1’…‘9’
若直接转成int类型则得不到字符数字本身，会转为他们的Ascll值
若想得到数值本身可以进行字符中间运算
在进行运算时，char、byte、short类型会自动转化为int类型
其中，char的字符转换为int会是他们的Ascll值，得不到字符数字本身；
若想得到字符本身，可通过-48[减48]或者 -‘0’ [减字符’0’],来获取int类型的数字字符本身

char a='9';
int b1='9';//57
int b2='0';//48
int b3='9'-0  //'9'-0 等价于(int)'9'-0[0本身是int类型] 即57-0 因此结果为57，int类型；
int b4=9-'0'; //9-'0' 等价于=9[9本身是int类型]-(int)'0'即9-48 因此结果为-39，int类型；
int b5='9'-'0';//'9'-'0' 等价于(int)'9'-(int)'0'即57-48 因此结果为9，int类型；

直接将数字字符当做数字，与其他类型进行加减乘除，是得到不到理想的结果
例如:

System.out.println((int)'5'); //转换为int类型的值为53
System.out.println('5'*7); //等价于(int)'5'*7=53*7 得到int类型的值为371
System.out.println(('5'-'0')*7); //等价于((int)'5'-(int)'0')*7=(53-48)*7=5*7=35
System.out.println(('5'-48)*7); //等价于((int)'5'-48)*7=(53-48)*7=5*7=35