Java笔记Day04(基础篇)

最新推荐文章于 2024-06-04 23:11:16 发布

Gemini高

最新推荐文章于 2024-06-04 23:11:16 发布

阅读量91

点赞数

分类专栏： Java_Note 文章标签： java jvm 开发语言

本文链接：https://blog.csdn.net/weixin_54665499/article/details/129822913

版权

Java_Note 专栏收录该内容

5 篇文章 0 订阅

订阅专栏

数组

数据存储在变量中，java提供数组作为容器管理"海量"数据，且存储的位置与变量不同，数组存储在堆(heap)内存中。

数组是引用数据类型，从内存结构上划分，属于堆。

int x = 10086;

String name = Gemini ;

虽然数据类型不同，数据存储位置不同，但是变量名都存储在虚拟机栈中。

数组特点：

1.可以存储重复的数据

2.只能存储相同数据类型

3.数组的长度（数组元素的个数）必须在定义时确定，在程序中不可改变

4.同一数组中的数组元素在内存中占据的内存空间是连续的

5.数组通过下标来存取值，下标从0开始，到数组的长度-1结束(如果下标≥数组长度则出现数组下标越界异常; IndexOutofBoundsException)

数组初始值：

byte	float	0.0f
short	double	0.0
int	boolean	flase
long	char	空格 ’\u0000’

一维数组

动态初始化

语法结构：数据类型[] 变量名 = new 数据类型[容器的大小];

new的意思就是代表在堆heap中开辟空间，myArray这个变量名就是堆中的内存地址，可作引用；开辟空间后，需要对空间赋值，如下

int[] myArray = new int[5];
myArray[0] = 11;
myArray[1] = 22;
myArray[2] = 33;
myArray[3] = 44;
myArray[4] = 55;
for(int i = 0;i < myArray.length; i++){//由于输出语句需要重复执行，使用for循环
    System.out.println(myArray[i]);
}
for(int i = myArray.length-1;i >= 0; i--){//倒序输出
    System.out.println(myArray[i]);
}
for(int i = 0;i < myArray.length; i++){//倒序输出
    System.out.println(myArray[myArray.length-1-i]);
}

静态初始化:

语法结构：数据类型[] 变量名 = { , , ... , };

数据类型[] 变量名 = new 数据类型[] { , , ... , };

int[] a = {1,2,3,4,5};
int[] b = new int[] {1,2,3};
//错误：int[] b = new int[3] {1,2,3};

String[] str = {"张三","李四","王五"};
for(int i = 0; i < str.length; i++){
    System.out.println(str[is]);
}

排序算法之冒泡排序

原理: 在一个无序数组中，相邻的两个数比较，将较大数向后移动，直到数组的末尾，下一次最大的数不参与比较

for(int i=0;i<array.length-1;i++){
    for(int j=0;j<array.length-1-i;j++){
        if(array[j] > array[j+1]){
            int temp = array[j];
            array[j] = array[j+1];
            array[j+1] = temp;
        }
    }
}

排序算法之选择排序

原理: 第一次从arr[0]~arr[n-1]中选取最小值，与arr[0]交换；第二次从arr[1]~arr[n-1]中选取最小值，与arr[1]交换；第三次从arr[2]~arr[n-1]中选取最小值，与arr[2]交换；......；第i次从arr[i-1]~arr[n-1]中选取最小的值,与arr[i-1]交换。

1.选择排序一共有数组长度-1轮排序

2.每一轮排序是一个循环。先假定arr[0]为最小值,然后和后面的每个数进行比较，如果发现有比当前数还小的数据,就重新确定最小的数,并记下下标;当遍历到数组的最后记录本轮最小数和下标,交换即可。

import java.util.Arrays;
public class Test {
    public static void main(String[] args) {
//--
        int[] arr = {5,23,2,6,4,2};
        for(int i=0; i<arr.length-1;i++) {//最外层循环控制的比较的次数
            int minIndex = i;
            int min = arr[i];
            for(int j=i+1;j <arr.length;j++) {
                if(min>arr[j]) { //说名假定的最小值，不是最小的
                    min = arr[j]; //重置最小值
                    minIndex = j; //重置最小值的下标
                }
            }
            //将最小值放在arr[0]交换 不相等的时候交换 相等就不交换了
            if(minIndex!=i) {
                arr[minIndex] = arr[i];
                arr[i] = min;
            }
            System.out.print("no"+(i+1)+":");
            System.out.println(Arrays.toString(arr));
        }
//--
    }
}

二分查找

import java.util.Arrays;
public class Test {
    public static void main(String[] args) {
        int number[] = { 1, 5, 8, 11, 19, 22, 31, 35, 40, 45, 48, 49, 55 };
        int min = 0;
        int max = number.length-1;
        int target = 1;
        while (min<=max) {
            int middle = min+max;//或int middle = (min+max) >> 1;
            if (number[middle] == target) {
                System.out.println("location:" + middle);
                break;
            } else if (number[middle]<target) {
                min = middle + 1;
            } else {
                max = middle - 1;
            }
        }
        if (min>max) {
            System.out.println("no");
        }
    }
}

二维数组

动态初始化

语法结构：数据类型[][] array = new 数据类型[一维数组的个数][一维数组元素的个数];

int[][] array = new int[2][4]; 
        //2行：指的是一个二维数组中有2个一维数组
        //4列：每个一维数组中，最大长度为4
array[0][0] = 2; //二维数组的第一个元素
        //2被存储到了二维数组中第一个一维数组的第一个位置
array[0][1] = 5; //二维数组的第一个元素
        //5被存储到了二维数组中第一个一维数组的第二个位置

静态初始化

语法结构：数据类型[][] array = { { , , ... , }, { , , ... , }, ... , { , , ... , } };

数据类型[][] array = new 数据类型[] { { , , ... , }, { , , ... , }, ... , { , , ... , } };

int[][] myArray1 = { {1,2,3,4},{5,6,7} };//2行4列
int[][] myArray2 = new int[][]{ {1,2,3},{4,5,6},{7,8,9,0} };//3行4列

System.out.println(myArray1[1]);//输出 [I@1a5e20ef
System.out.println(myArray2[1]);//输出 [I@9480ac4b

System.out.println(myArray1[1][2]);//输出7
System.out.println(myArray2[1][2]);//输出6

System.out.println(myArray1.length);//一维数组组数，即行数
System.out.println(myArray1[0].length);//第一个一维数组元素个数，即第一个一维数组列数

正序/倒序输出

import java.util.Arrays;
public class Test {
	public static void main(String[] args) {
		int[][] myArray = {{1,2,3},{4,5,6},{7,8,9}};
		for (int i=0;i<myArray.length;i++){
			for (int j=0;j<myArray[i].length;j++){
				System.out.print(myArray[i][j]+" ");
			}
		}
		System.out.println();
		for (int i=myArray.length-1;i>=0;i--){
			for (int j=myArray[i].length-1;j>=0;j--){
				System.out.print(myArray[i][j]+" ");
			}
		}
		System.out.println();
		for (int i=0;i<myArray.length;i++){
			for (int j=0;j<myArray[i].length;j++){
				System.out.print(myArray[myArray.length-1-i][myArray[i].length-1-j]+" ");
			}
		}
	}
}

将二维数组转化成一维数组

import java.util.Arrays;
public class Test {
	public static void main(String[] args) {
		int[][] myArray = {{1},{2,3},{4,5,6}};
		int count = 0;
		int flag = 0;
		for (int i = 0;i< myArray.length;i++){
			for (int j = 0;j< myArray[i].length;j++){
				count++;
			}
		}
		int[] list = new int[count];
		for (int i = 0;i< myArray.length;i++){
			for (int j = 0;j< myArray[i].length;j++){
				list[flag] = myArray[i][j];
				System.out.print(list[flag]);
			}
		}
	}
}

二维数组排序

import java.util.Arrays;
public class Test {
	public static void main(String[] args) {
		int[][] myArray = {{2,0},{1,3,7,9,2},{6,5,8}};
		int count = 0;
		int flag = 0;
		for (int i=0;i<myArray.length;i++){
			for (int j=0;j<myArray[i].length;j++){
				count++;
			}
		}
		int[] array = new int[count];
		for (int i=0;i<myArray.length;i++){
			for (int j=0;j<myArray[i].length;j++){
				array[flag++] = myArray[i][j];
			}
		}
		System.out.println("original:"+Arrays.toString(array));
		for (int m=0;m<array.length-1;m++){
			for (int n=0;n<array.length-1-m;n++){
				if (array[n]>array[n+1]){
					int temp = array[n];
					array[n] = array[n+1];
					array[n+1] = temp;
				}
			}
		}
		System.out.println("sort:"+Arrays.toString(array));
		flag = 0;
		for (int p=0;p<myArray.length;p++){
			for (int q=0;q<myArray[p].length;q++){
				myArray[p][q] = array[flag++];
			}
		}
		System.out.print("final:");
		for (int t=0;t<myArray.length;t++){
			System.out.print(Arrays.toString(myArray[t]));
		}
//        另一种输出形式
//		System.out.print("final:{");
//		for(int x=0;x<myArray.length;x++) {
//			System.out.print("{");
//			for(int y=0;y<myArray[x].length;y++) {
//				System.out.print(myArray[x][y]);
//				if(y != myArray[x].length-1) {
//					System.out.print(",");
//				}
//			}
//			System.out.print("}");
//			if(x != myArray.length-1) {
//				System.out.print(",");
//			}
//		}
//		System.out.print("}");
	}
}