目录
数组
数组：是一组相同数据类型元素的集合，是一个容器 数组中可以存储基本数据类型，也可以存储引用数据类型 数组创建时必须指定长度，创建后长度不能改变 数组中每个元素空间是连续的
数组的创建是 声明
package day1;
import java.util.Arrays;
public class demo1 {
public static void main(String[] args) {
/*//声明 创建数组
int[] a,b;
int b[],c;*/
int[] a = new int[5];//new 创建一个数组，并指定数组的长度（容量） 每个空间会赋予默认值 整数型默认值为0
System.out.println(a);//[I@1b6d3586--数组在内存中的地址（hash值）
//Arrays类，Java语言中提供的用于操作数组的工具类，提供排序，二分查找，数组复制....
System.out.println(Arrays.toString(a));//[0, 0, 0, 0, 0] toStrin(a) 把数组以字符串的形式返回，便于调试查看
int[] b = new int[]{1,2,3,4,5,6,7};
System.out.println(Arrays.toString(b));//[1, 2, 3, 4, 5, 6, 7]
int[] c = {1,2,3,4,5,6,7,8,9,10,11,12};
System.out.println(Arrays.toString(c));//[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]
String[] strings = new String[5];
System.out.println(Arrays.toString(strings));//[null, null, null, null, null] 引用数据类型的默认值为null
boolean[] d = new boolean[5];
System.out.println(Arrays.toString(d));//[false, false, false, false, false] Boolean类型的默认值为false
char[] e = new char[5];
System.out.println(Arrays.toString(e));//[ , , , , ] char类型的默认值为 （空格）
double[] f = new double[5];
System.out.println(Arrays.toString(f));//[0.0, 0.0, 0.0, 0.0, 0.0] 浮点型的默认值为0.0
byte[] g = new byte[5];
System.out.println(Arrays.toString(g));//[0, 0, 0, 0, 0] byte类型的默认值为0
}
}数组的下标使用
数组的访问
访问数组中的元素
数组名[索引/下标]
索引/下标：
从0开始
是整数（int）,数组长度最大值就是int的最大值 Integer.MAX_VALUE
数组最大索引 长度-1
数组长度
数组名/length
package day1;
public class demo2 {
public static void main(String[] args) {
int[] a = new int[5];//[0,0,0,0,0]
a[0] = 10;
System.out.println(a[0]);
/*//int[] b = new int[Integer.MAX_VALUE];//OutOfMemoryError
//System.out.println(b);
内存超载问题，内存不够
Exception in thread "main" java.lang.OutOfMemoryError: Requested array size exceeds VM limit
at day1.demo2.main(demo2.java:23)
*/
//a[5] = 5;
/*
数组下标越界异常
Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: 5
at day4.demo2.main(demo2.java:21)
*/
System.out.println(a.length);
}
}
数组的迭代
访问数组中的元素
数组名[索引/下标]
索引/下标：
从0开始
是整数（int）,数组长度最大值就是int的最大值
数组最大索引 长度-1
数组长度
数组名/length
for循环
package day1;
public class demo3 {
public static void main(String[] args) {
//for循环遍历数组，灵活的控制遍历的区间
int[] a = new int[]{1,2,3,4,5};
for(int i=0;i<a.length;i++){
System.out.println(a[i]);
}
}
}
增强for循环
package day1;
public class demo3 {
public static void main(String[] args) {
int[] a = new int[]{1,2,3,4,5};
//增强for循环，适合挨个的遍历每一个元素
//a--要遍历的数组
//int t--声明一个临时变量，用来接收每次循环时，从数组中取出的元素
//优点：写法简单 缺点：不能控制某一区间的遍历
for(int t : a){
System.out.println(t);
}
}
}
数组排序
冒泡排序
冒泡排序：
每次取出相邻的两个元素进行比较，将较大的向后移动，每比较一趟，可以找出一个最大值
5，4，3，2，1
1-4，3，2，1，5
2-3，2，1，4，5
3-2，1，3，4，5
4-1，2，3，4，5
package day1;
import java.util.Arrays;
public class sort1 {
public static void main(String[] args) {
int[] a = {5,4,3,2,1};
for(int i = 0;i<a.length-1;i++){//外层循环 控制比较趟数
//j<a.length-1是必要的 a.length-1-i中-i是优化算法
for(int j = 0;j<a.length-1-i;j++){//内层循环，相邻的两个元素进行比较 j j+1
if(a[j]>a[j+1]){//满足条件，交换位置
int temp = a[j];
a[j] = a[j+1];
a[j+1] = temp;
}
}
System.out.println(Arrays.toString(a));//交换过程
}
System.out.println(Arrays.toString(a));//交换结果
}
}
选择排序
选择排序：
从第一个元素开始，与之后的每一个元素比较，将较小的移动到前一个位置，以此类推
5，4，3，2，1
1-1，5，4，3，2
2-1，2，5，4，3
3-1，2，3，5，4
4-1，2，3，4，5
package day1;
import java.util.Arrays;
public class sort2 {
public static void main(String[] args) {
int[] a ={1,2,3,4,5};
//i<a.length-1:减少最后一行进行比较
for(int i = 0;i<a.length-1;i++){//控制比较的趟数
//int j = i+1：每循环一次，都要与之后的每一个元素进行比较
//j<a.length:每循环一次，都要与之后的每一个元素进行比较
for(int j = i+1;j<a.length;j++){
if(a[i]>a[j]){//进行比较，交换位置
int temp = a[i];
a[i]=a[j];
a[j]=temp;
}
}
}
System.out.println(Arrays.toString(a));
}
}
优化算法
package day1;
import java.util.Arrays;
public class sort2 {
public static void main(String[] args) {
int[] a ={1,2,3,4,5};
for(int i = 0;i<a.length-1;i++){
int minindex = i;//记录最小值的位置
for(int j = i+1;j<a.length;j++){
if(a[minindex]>a[j]){
minindex = j;//记录最小值的位置
}
}
//进行比较，交换位置
int temp = a[i];
a[i]=a[minindex];
a[minindex]=temp;
}
System.out.println(Arrays.toString(a));
}
}
二维数组
二维数组（多维数组）：数组的数组，数组中的每一个元素又是一个一维数组
声明，创建，遍历
二维数组的声明，创建
package day1;
public class demo4 {
public static void main(String[] args) {
/*
[3]:表示二维数组的长度是2
[5]:表示二维数组中，每一个一维数组的长度是5
{{0，0，0，0，0，}，{0，0，0，0，0，}，{0，0，0，0，0，}}
0 1 2
*/
/*int[][] a = new int[3][5];
System.out.println(a[2][3]);*/
/*
[3][]:之声明了二维数组的长度是3，并没有声明二维数组中的一维数组的长度，也就不会创建一维数组
{null,null,null}
*/
int[][] a = new int[3][];
a[0] = new int[10];
a[1] = new int[5];
a[2] = new int[7];
System.out.println(a[2][3]);
//int[][] a = new int[][]{{1,2,3},{4,5,6},{7,8,9}};
//int[][] a = {{1,2,3},{4,5,6},{7,8,9}};
}
}
二维数组的遍历
package day1;
public class demo5 {
public static void main(String[] args) {
int[][] a = {{1,2,3},{4,5,6},{7,8,9}};
for(int i=0;i<a.length;i++){//对二维数组进行遍历
for(int j=0;j<a[i].length;j++){//对一维数组进行遍历
System.out.println(a[i][j]+"\t");
}
System.out.println();//换行
}
}
}
733
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
