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；
引用数据类型作为返回值
//数组作为返回值。
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
二维数组其实是一维数组中存放着一维数组，栈中存放高维数组的地址，高维数组和低维数组存放在堆中，高维数组中存放低维数组的地址。低维数组存放实际数据。