可变参数：
可变参数：
可以不指定传入参数的个数，使用...表示，但是只能存放相同数据类型的。
如果还有其他参数，需要把可变参数放在参数列表的最后位置。
可变参数:JDK1.5开始支持，用连续的三个点表示 ...
-- 只能是同类型之间
-- 可变参数可以和固定参数结合使用，但是可变参数必须放在参数列表最后。
可变参数的参数列表：
格式：
修饰词 返回值类型 方法名 （数据类型 ... 可变参数名字）{
for(数据类型 参数名：可变参数名){} // for-each循环
}
(int ... nums) {
for(int num : nums) { // for-each 循环} }
package test.day04;
// 可变参数（JDK 1.5版本 可变参数）
// 只能是同类型之间求和
public class Test1 {
public static void main(String[] args) {
// 求和：n 个数。
// 已知参数个数
System.out.println(add(1,6));
// 未知参数个数，使用可变参数 int ... nums
int a = 5,b = 3;
System.out.println(add(a,b,10,33,24));
System.out.println(sum(2.1,2,4,2));
}
// 已知参数列表的参数个数
public static int add(int a,int b) {
return a+b;
}
// 未知参数列表的参数个数 -- 用可变参数
public static int add(int ... nums) {
int i = 0;
for(int num : nums) { // for-each 循环
i += num;
}
return i;
}
// 可变参数可以和固定参数结合使用，但是可变参数必须放在参数列表最后。
public static int sum(double a,int ...nums) {
int i = 0;
for(int num : nums) {
i += num;
}
i += a;
return i;
// return 1;
}
}
数组：
是一种数据结构，用来存放相同数据类型的数据。
是有序的元素序列，用于储存多个相同类型的数据
动态初始化：
语法：数据类型 [ ] 数组名 = new 数据类型 [ 数组长度 ];
静态初始化：
数据类型 [ ] 数组名 = new 数据类型 [ ] { 数组元素1,数组元素2,数组元素3,... };
简写：
数据类型 [ ] 数组名 = { 数组元素1,数组元素2,数组元素3,... };
当访问数组中根本不存在的下标时，会报错；数组下标越界异常
java.lang.ArrayIndexOutOfBoundsException: 5
遍历数组：
使用for循环
for(数组的起始下标;数组的最大下标;下标的变化规律){}
冒泡排序：
比较相邻两个元素的大小，如果前一个元素大于后一个元素，交换两个元素的值
双层for循环
外层循环控制轮数，内层循环控制每一轮的比较次数
比较相邻的两个数，如果前面的比后面的大，就交换值
数组的工具类：
(1)Arrays.toString():把数组转换成字符串的形式
(2)Arrays.sort():给无序数组排序，默认从小到大
(3)Arrays.copyOf():复制数组，也可以实现扩容和所缩容的效果，具体看方法的第二个参数值
Arrays.toString(); 把数组里的数据变成字符串展示出来
Arrays.sort(); 数组的排序，默认从小到大
Arrays.copyOf(); 复制数组，第一个参数是原数组名，第二个参数是新数组长度 存在扩容和缩容现象
二维数组：又称矩阵，用来存放数组的数组
数据类型[ ][ ] 二维数组名 = new 数据类型[数组个数][ ];
package test.day04;
/*
* 数组: 是有序的元素序列，用于储存多个相同类型的数据
*
* 动态初始化：
* 语法：数据类型 [ ] 数组名 = new 数据类型 [ 数组长度 ];
*
* 静态初始化：
* 数据类型 [ ] 数组名 = new 数据类型 [ ] { 数组元素1,数组元素2,数组元素3,... };
* 简写
* 数据类型 [ ] 数组名 = { 数组元素1,数组元素2,数组元素3,... };
*/
public class Test2_Array1 {
public static void main(String[] args) {
// 把 hello 存入数组
// 1. 动态初始化
// 数据类型 [ ] 数组名 = new 数据类型 [ 数组长度 ];
char [] a = new char [5]; // 数据类型默认值
System.out.println(a);
a[0] = 'h'; // 修改 a 数组里 0 下标处的数据，改成 h字符
a[1] = 'e'; // 修改 a 数组里 1 下标处的数据，改成 e字符
a[2] = 'l'; // 修改 a 数组里 2 下标处的数据，改成 l字符
a[3] = 'l'; // 修改 a 数组里 3 下标处的数据，改成 l字符
a[4] = 'o'; // 修改 a 数组里 4 下标处的数据，改成 o字符
System.out.println(a); // hello
System.out.println(a[0]);
System.out.println(a[1]);
// 当访问数组中根本不存在的下标时，会报错；数组下标越界异常
// java.lang.ArrayIndexOutOfBoundsException: 5
// System.out.println(a[5]);
// 2. 静态初始化
// 数据类型 [ ] 数组名 = new 数据类型 [ ] { 数组元素1,数组元素2,数组元素3,... };
// 简写
// 数据类型 [ ] 数组名 = { 数组元素1,数组元素2,数组元素3,... };
char [] b = new char [] {'h','e','l','l','o'};
System.out.println(b);
char [] c = {'h','e','l','l','o'};
System.out.println(c);
}
}
package com.test.day04;
import java.util.Random;
// 遍历数组
public class Test3_Array2 {
public static void main(String[] args) {
f1();
f2();
f3();
}
// 打印数组中的所有数据
public static void f1() {
// 1. 定义数组
String [] arr = {"上海","北京","桂林","成都","四川"};
System.out.println(arr); // [Ljava.lang.String;@15db9742
// 2. 遍历数组
/*
* int i = 0 -- 从下标为0的位置开始，i表示下标
* i <= arr.length-1 -- 下标最大值就是数组的长度-1
* 数组的长度 length
* i++ -- 下标的变化规律就是自增
*/
for(int i = 0; i <= arr.length-1; i++) {
// 根据下标获取arr数组里的数据
System.out.println(arr[i]);
}
}
// 遍历数组 存入 1-10
public static void f2() {
// 1.创建数组
int [] arr = new int [10];
// 2.遍历数组
for(int i = 0; i < arr.length; i++) {
// 修改数组中元素的值
arr[i] = i+1;
System.out.println(arr[i]);
}
}
// 创建一个长度为10的数组 并存入100以内随机数
public static void f3() {
Random ran = new Random();
// 1.创建数组
int [] arr = new int [10];
// 2.遍历数组
for(int i = 0; i < arr.length; i++) {
// 3.给每个元素重新赋值为随机数
arr[i] = ran.nextInt(100);
System.out.println(arr[i]);
}
}
}
package test.day04;
// 冒泡排序
public class Test4_BubbleSort {
public static void main(String[] args) {
// 定义一个数组
int [] arr = {57,20,64,82,2};
// 接收 return 过来的值 遍历出来
for(int i = 0; i<arr.length;i++) {
int [] newArr = method(arr);
System.out.println(newArr[i]);
}
}
public static int[] method(int[]arr) {
// 外层循环控制轮数
for(int i = 0; i< arr.length-1;i++) {
// 内层循环控制每一轮的比较次数
for(int j = 0; j < arr.length-1-i;j++) {
// 比较相邻的两个数，如果前面的数比后面大就交换值
if(arr[j]>arr[j+1]) {
int temp = arr[j];
arr[j] = arr[j+1];
arr[j+1] = temp;
}
}
}
return arr;
}
}
package test.day04;
import java.util.Arrays;
// 数组的工具类
/*
* Arrays 数组工具类的名字
* toString()
* sort()
* copyOf()
* Arrays.copyOf(original, newLength);
*/
public class Test5_Arrays {
public static void main(String[] args) {
method();
method2();
method3();
}
// toString() -- 把数组中的数据展示成了字符串
public static void method() {
char [] a = {'h','e','l','l','o'};
System.out.println(a); // hello
int [] b = {1,2,3,4,5};
System.out.println(b); // [I@15db9742
int [] arr = {11,22,33,44,55,66};
// 遍历数组
System.out.print("[");
for(int i = 0; i< arr.length; i++) {
if(i == arr.length-1) {
System.out.print(arr[i]+ "");
}else {
System.out.print(arr[i]+ ", ");
}
}
System.out.println("]");
// 使用工具类输出
System.out.println(Arrays.toString(arr));
}
// sort() -- 给数组排序 - - 默认从小到大
public static void method2() {
int [] arr = {3,8,1,25,2,55,12};
Arrays.sort(arr);
System.out.println(Arrays.toString(arr));
}
// copyOf() -- 复制数组
public static void method3() {
int [] arr = {3,8,1,25,2,55,12};
// 第一个参数是原数组名，第二个参数是新数组的长度
int [] arr2 = Arrays.copyOf(arr, 7);
System.out.println(Arrays.toString(arr2));
// [3, 8, 1]
// 缩容 -- 只从前面开始复制指定部分的数据，相当于是截取数据
int [] arr3 = Arrays.copyOf(arr, 3);
System.out.println(Arrays.toString(arr3));
// [3, 8, 1, 25, 2, 55, 12, 0, 0, 0]
// 扩容 -- 把数组赋值完毕后，添加新位置并填充数组默认值
int [] arr4 = Arrays.copyOf(arr, 9);
System.out.println(Arrays.toString(arr4));
}
}package com.huacit.day04;
import java.util.Arrays;
// 二维数组，又称矩阵，是存放数组的数组结构
public class Test6_TwoArray {
public static void main(String[] args) {
String[] p1 = {"lisi","100","80","90"};
System.out.println(Arrays.toString(p1));
String[] p2 = {"zhangsan","99","82","78"};
System.out.println(Arrays.toString(p2));
String[][] p = new String[2][4];
// [2] -- 代表 有两个数组
// 表示二维数组中的一维数组个数
// [4] -- 代表 每个数组里有4个元素
// 表示一维数组中的元素个数
p[0][0] = "lisi";
p[0][1] = "100";
p[0][2] = "80";
p[0][3] = "90";
p[1][0] = "zhangsan";
p[1][1] = "99";
p[1][2] = "82";
p[1][3] = "78";
System.out.println(p.length);
System.out.println(p[0].length);
System.out.println(p[1].length);
System.out.println(Arrays.toString(p));
// [[Ljava.lang.String;@15db9742, [Ljava.lang.String;@6d06d69c]
System.out.println(Arrays.toString(p[0]));
// [lisi, 100, 80, 90]
System.out.println(Arrays.toString(p[1]));
// [zhangsan, 99, 82, 78]
// 遍历
for(int i = 0; i < p.length; i++) {
System.out.println(p[i]);
for(int j=0;j<p[i].length;j++) {
System.out.println(p[i][j]);
}
}
}
}
内存图：
在局部变量中，基本数据类型存放在栈里，引用数据类型存放在堆里，
对象的声明存放栈里，new出来的存放在堆里
扫一扫
1305
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
