Java基础学习 day_03

return 不管后面有什么，直接结束方法，返回值。

IDEA的使用

下载IDEA的地址如下：
下载IDEA

卸载IDEA
1.先把注册信息清除了。help—>register
2.从控制面板中删除和添加程序中找到idea安装项目右击删除，选择删除配置和缓存。

IDEA安装目录下的文件
bin：可执行文件
help：帮助文件快捷键
jar64：自带的jre允许环境
lib：开发中需要的jar包
license ：插件许可证文件
plugins：插件
redist：Apache License 目录

遍历数组
增强for循环(jdk1.5)。

//增强for jdk
int[] b={1,3,6,6,5};
for (int i : b) {
    System.out.print(i+"--");
}
System.out.println();
//答案
1--3--6--6--5--

增强for循环只适合遍历

package QFTest;
public class Test_10 {
    public static void main(String[] args) {
        int[] arrs={2,4,5,1,3,4};
        System.out.println("增强for循环执行加5操作");
        for (int arr : arrs) {
            arr=arr+5;
        }
        for (int arr : arrs) {
            System.out.print(arr+"  ");
        }
        System.out.println();
        System.out.println("普通for循环执行加5操作");
        for (int i = 0; i < arrs.length; i++) {
            arrs[i]+=5;
        }
        for (int arr : arrs) {
            System.out.print(arr+"  ");
        }
    }
}
//答案
增强for循环执行加5操作
2  4  5  1  3  4  
普通for循环执行加5操作
7  9  10  6  8  9

栈：存储基本数据类型以及引用类型的地址。空间小，存储速度快，jdk1.5之前是256k，jdk1.5之后1M。先进后出。
堆：存储引用数据类型的实际数据，空间比较大，存储的速度慢。
对于数组来说，数组属于引用数据类型，数组的地址存放在栈中，而数据存储在堆中。
访问一个数组的地址。直接输出数组变量名。

数组下标越界，会出现java.lang.ArrayIndexOutOfBoundsException

数组的扩充

数组有四种命名方式

package QFTest;

public class Test_01 {
    public static void main(String[] args) {
        //第一种声明方式
        int[] a=new int[5];
        a[0]=1;
        a[1]=2;
        a[2]=3;
        a[3]=4;
        a[4]=5;
        for (int i : a) {
            System.out.print(i+"--");
        }
        System.out.println();
        //第二种声明方式
        int[] b={1,3,6,6,5};
        for (int i : b) {
            System.out.print(i+"--");
        }
        System.out.println();
        //第三种声明方式
        int[] c=new int[]{2,3,5,6,5};
        for (int i : c) {
            System.out.print(i+"--");
        }
        System.out.println();
        //第四种声明方式
        int[] d;
        d=new int[4];
        d[0]=1;
        d[1]=1;
        d[2]=1;
        d[3]=1;
        for (int i : d) {
            System.out.print(i+"--");
        }
        System.out.println();

    }
}

数组扩充

原数组必须确定数组的长度
1.创建大于原数组长度的新数组
2.将新数组的地址给原数组

package QFTest;
//数组扩充
//因为a的地址存储在栈中，它的地址指向堆中的实际数据。
//b数组的地址存储在栈中，把a数组的实际数据赋给b.b的地址指向堆中的新的实际数据。
//把b的地址赋给a，a的地址就指向了b所指向的实际数据。
//a原先指向的实际数据变成了垃圾。
public class Test_03 {
    public static void main(String[] args) {
        int[] a=new int[]{1,2,3,4,5};
        int[] b=new int[10];
        for (int i = 0; i < a.length; i++) {
            b[i]=a[i];
        }
        a=b;
        for (int i : a) {
            System.out.print(i+"-");
        }
        System.out.println();
        System.out.println(a);
        System.out.println(b);
    }
}
//答案
1-2-3-4-5-0-0-0-0-0-
[I@1b6d3586
[I@1b6d3586

数组的复制

1.System.arraycopy()
2.java.util.Arrays.copyOf(原数组，长度) 有返回值

package QFTest;
//System.arraycopy(原数组，元素组的起始位置，新数组，新数组的起始位置，读取的长度)
//java.util.Arrays.copyOf(原数组, 新长度);//返回带有原值的新数组。
public class Test_12 {
    public static void main(String[] args) {
        int[] a={2,3,55,1,4};
        int[] b=new int[10];
        int[] c=new int[6];
        System.arraycopy(a,1,b,2,2);
        System.out.println("System.arraycopy()方法");
        for (int i : b) {
            System.out.print(i+"  ");
        }
        System.out.println();
        c=java.util.Arrays.copyOf(a, 4);
        System.out.println("java.util.arrays.copyof()f方法");
        for (int i : c) {
            System.out.print(i+"  ");
        }
    }
}
//答案
System.arraycopy()方法
0  0  3  55  0  0  0  0  0  0  
java.util.arrays.copyof()f方法
2  3  55  1

（重点）基本类型传递的是变量中的值；引用类型传递的是变量中的地址

基本数据在栈中，引用数据类型地址在栈中，而实际数据在堆中。
比如

//数组  基本数据类型作为参数
package QFTest;
public class Test_04 {
    public static void main(String[] args) {
        int mainnum=10;
        int[] mainarrays={3,4,5,5,4};

        transArray(mainnum, mainarrays);
        System.out.println("主函数下的数组");
        for (int mainarray : mainarrays) {
            System.out.print(mainarray+"--");
        }
        System.out.println();
        System.out.println("主函数下的变量值");
        System.out.println(mainnum);
    }
    public static void transArray(int num,int[] arrs){
        for (int i = 0; i <arrs.length ; i++) {
            arrs[i]=arrs[i]+7;
        }
        num+=5;
        System.out.println("方法中的数组");
        for (int arr : arrs) {
            System.out.print(arr+"--");
        }
        System.out.println();
        System.out.println("方法中的变量值");
        System.out.println(num);
    }
}
//答案
方法中的数组
10--11--12--12--11--
方法中的变量值
15
主函数下的数组
10--11--12--12--11--
主函数下的变量值
10

引用数据类型传到方法里，是把地址传给了方法，arrs也指向了该地址，进行加减操作，则mainarrays也改变。而基本数据类型传入方法，是把值传给了方法，使num=10,num+5,是使num加五，而mainnum还是等于10；

扫描二维码关注公众号，回复： 11443207 查看本文章

引用数据类型作为返回值

//数组作为返回值。
package QFTest;
public class Test_05 {
    public static void main(String[] args) {
        int[] arrs={2,4,5,2,4};
        System.out.println("原数组的地址");
        System.out.println(arrs);
        arrs=arrays(arrs);
        System.out.println("赋值之后原数组的地址");
        System.out.println(arrs);
        for (int arr : arrs) {
            System.out.print(arr+"  ");
        }
    }
    public static int[] arrays(int[] arrs){
        int[] newarrs=new int[arrs.length*2];
        for (int i = 0; i < arrs.length; i++) {
            newarrs[i]=arrs[i];
        }
        System.out.println("方法中数组的地址");
        System.out.println(newarrs);
        return newarrs;
    }

}
//答案
原数组的地址
[I@1b6d3586
方法中数组的地址
[I@4554617c
赋值之后原数组的地址
[I@4554617c
2  4  5  2  4  0  0  0  0  0

可变长参数

//可变长参数
//可变长参数
package QFTest;
public class Test_11 {
    public static void main(String[] args) {
        System.out.println("第一种方式");
        arrays(1,2,3,4,5);
        System.out.println();
        System.out.println("第二种方式");
        arrays(new int[]{2,3,4,5,6});
        newarrays(12, 2, 1,2,3,4,5);
        newarrays(2, 3, new int[]{2,3,4,5,6});

    }
    public static void arrays(int... arrs){
        for (int arr : arrs) {
            System.out.print(arr+"  ");
        }
    }
    public static void newarrays(int a, int b,int... arrs){
        System.out.println();
        System.out.println("可变长参数只能放最后面且只有一个");
        System.out.println(a);
        System.out.println(b);
        for (int arr : arrs) {
            System.out.print(arr+"  ");
        }
    }
}
//答案
第一种方式
1  2  3  4  5  
第二种方式
2  3  4  5  6  
可变长参数只能放最后面且只有一个
12
2
1  2  3  4  5  
可变长参数只能放最后面且只有一个
2
3
2  3  4  5  6

一个方法只能有一个可变参数，且可变参数必须放在方法参数的最后

java中自带排序的方法。JDK排序：java.util.Arrays.sort(数组名); //JDK提供（升序）

//自带的排序方法
package QFTest;
public class Test_14 {
    public static void main(String[] args) {
        int[] a={3,5,33,4,7,54,33,11,4,1};
        java.util.Arrays.sort(a);
        for (int i : a) {
            System.out.print(i+"  ");
        }
    }
}
//答案
1  3  4  4  5  7  11  33  33  54

二维数组

四种声明方式。
•先声明、再分配空间：数据类型[][] 数组名; 数组名 = new 数据类型[高维长度][低维长度];
• 声明并分配空间：数据类型[][] 数组名 = new 数据类型[高维长度][低维长度];
• 声明并赋值（繁）：数据类型[][] 数组名 = new 数据类型[高维长度][]; //不规则数组，自行new低维数组
• 声明并赋值（简）：数据类型[][] 数组名 = { {v1,v2,v3},{v4,v5},{v6,v7,v8,v9} }; //显示初始化

高维的长度：arrs.length
低维的长度：arrs[0].length
在这里插入图片描述二维数组其实是一维数组中存放着一维数组，栈中存放高维数组的地址，高维数组和低维数组存放在堆中，高维数组中存放低维数组的地址。低维数组存放实际数据。