重温JavaSE06

数组(理解)

背下面干货分享

public static void main(String[] args) {
    //1.已知一二个整型数组，存储了5个值，求5个值的和
    //int[] nums = new int[5];
    int[] nums = new int[]{34,67,90,22,99};
    int sum = 0;
    //sum = nums[0] + nums[1] + nums[2] + nums[3] + nums[4];
    for (int i = 0; i < nums.length; i++) {
        sum += nums[i];
    }
    System.out.println("五个数的和是"+sum);
    /*
      【数组】是一种变量，引用数据类型变量
          学习数组的原因：
            随着互联网行业的发展，存储的数据信息开始剧增，原来的单个变量存储已经变得力不从心
            同时单个变量的存储存在隐患问题(当很多变量名同时操作时，难免会调用错误的变量名，导致错误)
          数组解决的问题：
            1.一个数组可以存储超大数据量 2.只有一个数组名，操作不易出错 3.借助下标操作数据方便 4.前提条件(数据量大)
          使用数组：
            数组                  VS                普通变量

          声明数组int[] a;                         声明变量int a;
          分配空间:a=new int[5];
          --合并：int[] a = new int[5]
          赋值(三种方式)                            赋值a = 90;
            静态赋值:int[] a ={1,2,3}
            int[] a = new int[]{1,2,3}
            动态赋值:a[0] = 4;
            默认赋值:默认为:0、0.0、false、null
          使用:数组的每一步操作都离不开循环           使用
         */
}

最值问题、查询问题、添加元素、删除元素（要会编）

import org.junit.Test;
import java.util.Arrays;
@Test
public void test01(){
    int[] nums ={34,90,-2,99,6};
    methodMax(nums);

    int index = getIndexByArr(nums,3);
    System.out.println(index == -1?"没找到":"查询3的下标位置为："+index);

    String[] strs = new String[4];//默认null
    strs[0] = "长春";
    strs[1] = "哈尔滨";
    strs[2] = "北京";
    System.out.println("原数组："+Arrays.toString(strs));
    System.out.println("插入到最后："+Arrays.toString(addArr(strs,"吉林")));//最后插入指定元素
    System.out.println("再按位置插入："+Arrays.toString(addArr(strs,"上海",2)));//按位置插入
    System.out.println("当前数组信息："+Arrays.toString(strs));
    System.out.println("按位置删除："+Arrays.toString(deleteArr(strs,2)));//按位置删除
    System.out.println("按元素删除："+Arrays.toString(deleteArr(strs,"长春")));//删除指定元素
}
public static void methodMax(int[] nums){//数组的最值问问题
    int max = nums[0];
    int min = nums[0];
    for (int i = 0; i < nums.length; i++) {
        if (nums[i] > max){
            max = nums[i];
        }
        if (nums[i] < min){
            min = nums[i];
        }
    }
    System.out.println("该数组最大值是："+max);
    System.out.println("该数组最小值是："+min);
}
public static int getIndexByArr(int[] nums,int value){//数组的查询问题(根据下标查元素nums[4]，根据元素查下标)
    int index = -1;
    for (int i = 0; i < nums.length; i++) {
        if (nums[i] == value){
            index = i+1;
            break;
        }
    }
    return index;
}
public static String[] addArr(String[] strs,String str) {//元素的添加1.空间够用(存储的位置,其他后移)2.空间不够用(重新创建新数组，将老数组复制过来)
    int i = 0;
    for (; i < strs.length; i++) {
        if (strs[i] == null){//1.表示该元素没有内存地址 2.不能.equals()会空指针异常(空对象.了)
            strs[i] = str;
            break;
        }
    }
    if (i == strs.length){//空间满了
        String[] newStr = new String[strs.length * 2];
        for (int j = 0; j < strs.length; j++) {
            newStr[j] = strs[j];
        }
        newStr[i] = str;
        return newStr;
    }
    return strs;
}

public static String[] addArr(String[] strs,String str,int site) {
    site = site - 1;//数组从0开始
    //        if (strs[strs.length - 1] != null) {//没空间存
    //        }
    String[] newStr = new String[strs.length * 2];//够不够都开空间
    for (int j = 0; j < strs.length; j++) {
        newStr[j] = strs[j];
    }
    newStr[newStr.length - 1] = str;
    String t = null;
    for (int i = 0; i < newStr.length; i++) {
        if (i == site) {
            for (int j = newStr.length - 1; j > i; j--) {
                t = newStr[j];
                newStr[j] = newStr[j - 1];
                newStr[j - 1] = t;
            }
        }
    }
    return newStr;
}
public static String[] deleteArr(String[] strs,int site){//元素的删除1.删除指定位置上的元素
    site = site - 1;//因为下标从0开始
    if (site > strs.length || site <= 0){
        System.out.println("不存在该位置");
    }else {
        for (int i = site; i < strs.length - 1; i++) {
            strs[i] = strs[i + 1];
        }
        strs[strs.length - 1] = null;
    }
    return strs;
}
public static String[] deleteArr(String[] strs,String str){//元素的删除2.删除指定元素
    String t;
    Boolean flag = false;
    for (int i = 0; i < strs.length - 1; i++) {
        if (strs[i].equals(str)){
            flag = true;
            t = strs[i];
            strs[i] = strs[i + 1];
            strs[i + 1] = t;
        }
    }
    if (flag){
        strs[strs.length - 1] = null;
    }else {
        System.out.println("该元素不存在");
    }
    return strs;
}

数组默认初始值：

类型	初始值
整型	0
浮点型	0.0
char	‘\u0000’
boolean	false
引用数据类型	null

其他(理解)

数组定义：

存储相同类型数据的有序(存储顺序一样)集合，每个数据被称作一个元素，每个元素可通过下标来访问

其他(重点)

数组的四个特点：

长度确定，数组一旦被创建，大小就是不可变的。

数组类型可以任意类型，数组元素的类型必须相同

数组有下标，从0到数组.length-1

数组属于引用类型变量，数组也是对象

增强for(了解)

增强for(foreach)循环，只是遍历，不能对下标进行操作

public void test(){
    int [] nums=new int[5];
    int sum=0;
    Scanner sc=new Scanner(System.in);
    for (int i = 0; i < 5; i++) {
        System.out.println("请输入第"+(i+1)+"个数");
        nums[i]=sc.nextInt();
    }
    for (int i:nums) {//i代表每个元素，nums是数组名
        sum += i;
    }
    System.out.println("这5个数的和是："+sum);
    System.out.println("输入的5个数分别为：");
    for (int i:nums) {
        System.out.print(i+"\t");
    }
    /*
        增强for(forEach)循环，只是遍历，不能对下标进行操作
    */
}

可变参数(了解)

作用提供了一个方法，参数的个数是可变的 ,解决了部分方法的重载问题

方法的内部对可变参数的处理跟数组是一样

可变参数和其他数据一起作为形参的时候，可变参数一定要放在最后

我们自己在写代码的时候，建议不要使用可变参数(直接用数组、集合就行)。

public static void main(String[] args) {
    //定义方法求两个数相加、三个数相加、四个数相加...
    Demo3 demo3 = new Demo3();
    System.out.println(demo3.getSumByNums(23,90));
    System.out.println(demo3.getSumByNums(23,77,90,10,100,200));
    System.out.println(demo3.getSumByNums(10));
    System.out.println(demo3.getSumByNums());
    /*
        可变参数：(用来看源代码)
        1.什么是可变参数：我不确定有多少个同类型参数，
          目前 对于不确定个数的参数  解决方法-->方法重载
          新地解决方案：可变参数
          替代方案：数组、集合作为参数（约等于可变参数）
         */
}
public int getSumByNums(int ... nums){//把可变参数就当做是数组一样，参数列表中必须放在最后
    int sum = 0;
    for (int i:nums) {
        sum += i;
    }
    return sum;
}

Arrays工具类(重点)

Arrays是对数组操纵的工具类	说明	例子arr原来为：[1, 3, 7, 2, 4, 8]	结果
toString(数组)	以字符串形式打印数组内容	Arrays.toString(arr);	[1, 3, 7, 2, 4, 8]
sort(数组)	数组升序排序	Arrays.sort(arr);	[1, 2, 3, 4, 7, 8]
binarySearch(数组,值)	(要是已排序的数组) 二分查找对应值的下标	Arrays.binarySearch(arr,4);	排序后查找是3
copyOf(数组,长度);	复制数组，定义新长度	Arrays.copyOf(arr, 4);	[1, 3, 7, 2]
copyOfRange(位置,位置-1);	区间复制数组[左闭右开)	Arrays.copyOfRange(arr, 1, 4)	[3, 7, 2]
equals(数组1, 数组2);	比较两个数组是否相等	Arrays.equals(arr3, arr4)	true
fill(数组,填充值);	数组全部填充为该值	Arrays.fill(arr5, 9);	[9, 9, 9, 9, 9, 9]

基本数据类型和引用数据类型在赋值/传值时的区别(理解)

public static void main(String[] args) {
    method();
    /*
        基本数据类型在 赋值/传值 的时候，是将值 复制一份 传递走
        引用数据类型在 赋值/传值 的时候，是将内存地址 复制一份 传递走
         */
}
public static void method(){
    /**
         * （1）张三去年高 160，李四跟他一样高；
         * 张三今年长高了5厘米，李四没变；
         * 问 去年 和  今年 张三 李四分别多高？
         *
         * （2）张三去年高160，重60；李四跟他一样；
         * 张三今年长高了5厘米，加重了5公斤，李四没变
         * 问 去年 和  今年    张三 李四分别多高多重？
         */
    /*  int zs=160;
        int ls=zs;
        System.out.println("去年张三高"+zs+"，李四高"+ls);
        zs+=5;
        System.out.println("去年张三高"+zs+"，李四高"+ls);*/

    int[] zs={165,65};//0x34ert
    //int[] ls=zs;  //0x34ert
    int[] ls=new int[2];//新地址
    ls[0]=zs[0];
    ls[1]=zs[1];
    System.out.println("去年张三高"+zs[0]+"重"+zs[1]+"，李四高"+ls[0]+"重"+ls[1]);
    zs[0]=zs[0]+5;
    zs[1]=zs[1]+5;
    System.out.println("去年张三高"+zs[0]+"重"+zs[1]+"，李四高"+ls[0]+"重"+ls[1]);
}