java学习日志（七）-- 数组Array

最新推荐文章于 2023-07-17 17:47:04 发布

铁匠铺掌柜

最新推荐文章于 2023-07-17 17:47:04 发布

阅读量280

点赞数

分类专栏： java学习日志文章标签：学习日志 java 数组 array

本文链接：https://blog.csdn.net/qq_32648327/article/details/66475468

版权

java学习日志专栏收录该内容

13 篇文章 2 订阅

订阅专栏

以前学习数组时写的一些小程序--主要是跟着老毕学的。

class ArrayDemo
{
	public static void main(String[] args){
//		两种方法均可
//		int[] arr = new int[2];
//		int arr = new int[2];
//		数组静态初始化
//		int[] arr = new int[]{1,2,3};
//		int[] arr = {1,2,3};
		
		int [] arr = new int[3];
		System.out.println(arr[1]);
		arr = null;
		System.out.println(arr[1]);
		//ArrayIndexOutOfBoundsException：数组角标越界异常，操作数组时，访问到了数组中不存在的角标。
		//NullPointerException：空指针异常，当引用没有任何指向值为null的情况，该引用还在用于操作实体。
	}
}

class ArrayDemo2
{
	public static void main(String[] args){
//		数组中的操作：
//		获取数组中的元素
		
//		int[] arr = new int[3];
//		数组中有一个属性可以直接获取到数组元素的个数—length
//		使用方式：数组名称.length
		int[] arr = { 2, 3, 4, 5, 12};
//		System.out.println( arr.length );
//		for(int x = 0; x < arr.length; x++){
//			System.out.println("arr[" + x + "]=" + arr[x]);
//		}

//		[I@[I@15db9742
//		“[”--表示数组
//		“I“--表示数组类型是Integer
//		“15db9742“--哈希算法算出的数组地址，哈希值，十六进制
		System.out.println(arr);
		printArray(arr);
		printArray(arr);
	}

	//定义一个功能，用于打印数组中的元素。元素间用逗号隔开。
	public static void printArray(int[] arr){
		for(int x = 0; x < arr.length-1;  x++){
			System.out.print(arr[x] + ",");
		}
		System.out.println(arr[arr.length-1]);
	}
}

class ArrayText
{
	public static void main(String[] args){
	/*
		获取数组中的最大值，最小值
		思路：
			1、获取最值需要进行比较，每一次比较都会有一个较大的值。因为该值不确定，通过一个变量进行临时存储。
			2、让数组中的每一个元素都和这个变量中的值进行比较，如果大于了变量中的值，就用该变量记录较大的值。
			3、当所有的元素都比较完成，那么改变量中存储的就是数组中的最大值了。

		步骤：
			1、定义变量。初始化为数组中任意一个元素即可。
			2、通过循环语句对数组进行遍历。
			3、在遍历过程中定义判断条件，如果遍历到的元素比变量中的元素大时，就赋值给该变量。

		需要定义一个功能来完成，以便提高复用性。
			1、明确结果，数组中最大元素， int。
			2、未知内容，一个数组， int[]
	*/
	int[] arr = {2, 4, 5, 6, 123, 45, 11};
	System.out.println(getMax(arr));
	System.out.println(getMaxx(arr));

// boolean型数组默认值是false
	boolean[] ar = new boolean[3];
	System.out.println(ar[1]);

	}
	public static int getMax(int[] arr){
		int max = arr[0];
		for(int i = 0; i < arr.length; i++){
			if(arr[i] > max)
				max = arr[i];
		}
		return max;
	}	

	/*
	获取最大值的另一种方式。
	将临时变量初始化为数组中任意一个角标。
	*/
	public static int getMaxx(int[] arr){
		int maxx = 0;
		for(int x = 0; x < arr.length; x++){
			if (arr[x] > arr[maxx])
			{
				maxx = x;
			}
		}
		return arr[maxx];
	}

	/*
	获取double类型数组的最大值。因为功能一致，所以函数名称相同。以重载形式存在。
	public static double getMax(double[] arr){
	

	return double;
	}
	*/
}

import java.util.Arrays;

class ArrayText2
{
	public static void main(String[] args){
	
	int[] arr = { 4, 5, 6, 23, 1, 3};
	selectSort(arr);
	printArr(arr);

	int[] ar = { 4, 5, 6, 23, 1, 3};
	bubbleSort(ar);
	printArr(ar);

	int[] a = { 4, 5, 6, 23, 1, 3};
	System.out.println("自带排序方法：");
	Arrays.sort(a);
	printArr(a);
	}

	//选择排序
	public static void selectSort(int[] arr){
		System.out.println("选择排序分步结果：");
		for(int x = 0; x < arr.length - 1; x++){
			for(int y = x + 1; y < arr.length; y++){
				if(arr[x] > arr[y]){
					printArr(arr);
					int temp = arr[x];
					arr[x] = arr[y];
					arr[y] = temp;
					
				}
			}
		}
	}

	//冒泡排序
	public static void bubbleSort(int[] arr){
		System.out.println("冒泡排序分步结果：");
		for (int x = 0; x < arr.length -1; x++) //for(int x=arr.length-1; x>0; x--)
		{																//for(int y=0; y<x; y++)
			for(int y = 0; y < arr.length - x -1; y++){ //-x:让每一次比较的元素减少， -1：避免角标越界
				if (arr[y] > arr[y+1])
				{
					printArr(arr);
					int temp = arr[y];
					arr[y] = arr[y+1];
					arr[y+1] = temp;
					
				}
			}
		}
	}

	//打印数组
	public static void printArr(int[] arr){
		System.out.print("[ ");
		for(int i : arr){
			System.out.print(i + " ");
		}
		System.out.println("]");
	} 
}

class ArrayText3
{
	public static void main(String[] args){
		int[] arr = {3, 1, 32, 15, 12, 7, 12};
		int index = getIndex(arr, 12);
		System.out.println("index=" + index);

		int[] ar = {2, 3, 5, 7, 12, 34, 57};
		System.out.println("index=" + halfSearch(ar,345));
		System.out.println("index=" + halfSearch_2(ar,55));
	}
	//定义功能：获取key第一次出现的位置。如果返回-1，那么代表该key在数组中不存在。
	public static int getIndex(int[] arr, int key){
		for(int x = 0; x < arr.length; x++){
			if (arr[x] == key)
			return x;
		}
		return -1;
	}

	public static int getIndex_2(int[] arr, int key){
		int min, max, mid;
		min = 0;
		max = arr.length - 1;
		mid = (min + max) / 2;

		while(arr[mid] != key){
			if(arr[mid] > key){
				max = mid -1;
			} else {
				min = mid +1;
			}
			mid = (min + max) / 2;
			if(min > max)
				return -1;
		}
		return min;
	}

//折半查找，提高效率，但是必须要保证数组时有序的
	public static int halfSearch(int[] arr, int key){
		int min, max, mid;
		min = 0;
		max = arr.length - 1;
		mid = (min + max) / 2;

		while(arr[mid] != key){
			if(arr[mid] > key){
				max = mid -1;
			} else {
				min = mid +1;
			}
			mid = (min + max) / 2;
			if(min > max)
				return -1;
		}
		return mid;
	}

//	折半查找的第二种方式
	public static int halfSearch_2(int[] arr, int key){
		int min = 0, max = arr.length - 1, mid;
		while (min <= max)
		{
			mid = (min + max) >> 1;
			if (key > arr[mid])
			{
				min = mid + 1;
			} else if (key < arr[mid]){
				max = mid - 1;
			} else {
				return mid;
			}
		}
		return -1;
	}
}

class ArrayText4
{
	public static void main(String[] args){
//		toBin(6);	
		toHex(60);
	}

	public void ArrayText4(){}

// 10进制-->16进制
//	public static void toHex(int num){
//		StringBuffer sb = new StringBuffer();
//		for(int x = 0; x < 8; x++){
//			int temp = num & 15; //&0000 0000 0000 0000 0000 0000 0000 1111，每次取得四位
//			if(temp > 9)
//				sb.append((char)(temp - 10 + 'A'));
//			else
//				sb.append(temp);
//			num = num >>> 4;
//		}
//		System.out.println(sb.reverse());
//	}

// 10进制-->2进制
	public static void toBin(int num){
		StringBuffer sb = new StringBuffer();
		while(num > 0) {
			sb.append(num % 2);
			num /= 2;
		}
		System.out.println(sb.reverse()); //反转
	}

//	查表法：将所有元素临时存储起来。建立对应关系。
// 每一次&15后的值作为索引去查建立好的表，就可以找到对应的元素。
// 表的建立：通过数组

	public static void toHex(int num){
		char[] chs = {'0','1','2','3','4','5','6','7','8','9','A','B','C','D','E','F'};

//		定义一个临时容器
		char[] arr = new char[8];
		int pos = 0;
		while( num != 0 ) { //移位后形成的新数不为0,这样可以去除多余的0
			int temp = num & 15;
//			System.out.println(chs[temp]);
			arr[pos++] = chs[temp];
			num = num >>> 4;
		}

		for (int x = pos - 1; x >= 0; x--)
		{
			System.out.print(arr[x]);
		}
		System.out.println();
	}

}

class ArrayText5
{
	public static void main(String[] args){
		toBin(0);
		toBin(60);
		toBin(-60);
		toOct(60);
		toOct(-60);
		toHex(60);
		toHex(-60);
	}
// 10进制 --> 2进制
	public static void toBin(int num){
		trans(num,1,1);
		System.out.println();
	}

// 10进制 --> 8进制
	public static void toOct(int num){
		trans(num,7,3);
		System.out.println();
	}

// 10进制 --> 16进制
	public static void toHex(int num){
		trans(num,15,4);
		System.out.println();
	}

	public static void trans(int num, int base, int offset){
		if (num == 0) {
			System.out.print(0);
			return;
		}
		char[] chs = {'0','1','2','3','4','5','6','7','8','9','A','B','C','D','E','F'};
		char[] arr = new char[32];
		
		int pos = arr.length;
		while(num != 0){
			int temp = num & base;
			arr[--pos] = chs[temp];
			num = num >>> offset;
		}
		for(int x = pos; x < arr.length; x++){
			System.out.print(arr[x]);
		}
	}
}