数组

最新推荐文章于 2024-09-14 18:05:29 发布

维_Jacky

最新推荐文章于 2024-09-14 18:05:29 发布

阅读量304

点赞数

分类专栏：温习基础文章标签：各种类的方法使用数组

本文链接：https://blog.youkuaiyun.com/qq_36633450/article/details/84393900

版权

温习基础专栏收录该内容

17 篇文章

订阅专栏

本文详细介绍了Java中数组的排序（冒泡排序、选择排序）、查找（普通查找、二分查找）以及Arrays工具类的使用。同时，讨论了包装类的功能，如Integer的进制转换方法，Character的字符操作方法。还涵盖了BigInteger和BigDecimal的大数运算，以及Math类的数学计算方法、Random类的随机数生成和System类的系统操作。最后，讲解了Date类与SimpleDateFormat类在日期处理中的应用。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

DAY10

一、排序
冒泡排序：
思想：遍历数组的元素，两两之间进行比较，当数组第一个遍历遍历结束时，最大值就出现在了最大索引处

图解说明：

package cn.edu360;

public class ClassDemo {
	public static void main(String[] args) {
		int[] arr = {2, 4, 11, 0, -4, 333, 90};
		//数组遍历
		showArray(arr);
		bubbleSort(arr, true);//升序
		showArray(arr);
		bubbleSort(arr, false);//降序
		showArray(arr);
	}
	private static void bubbleSort(int[] arr, boolean isAsc) {
		//总共遍历的次数arr.length-1
		for (int i = 1; i < arr.length; i++) {
			for (int j = 0; j < arr.length-i; j++) {
				if(isAsc){//升序
					if(arr[j] > arr[j+1]){//发现前面的值大于后面的值，就进行值的替换
						swap(arr, j, j+1);
					}
				}else{//降序
					if(arr[j] < arr[j+1]){//发现前面的值小于后面的值，就进行值的替换
						swap(arr, j, j+1);
					}
				}
				
			}
		}
	}
	private static void swap(int[] arr, int i, int j) {
		int temp = arr[i];
		arr[i] = arr[j];
		arr[j] = temp;
	}
	private static void showArray(int[] arr) {
		for (int i = 0; i < arr.length; i++) {
			if(arr.length == 1){
				System.out.println("["+arr[i]+"]");
			}else if(i == 0){
				System.out.print("["+arr[i]+",");
			}else if(i == arr.length-1 ){
				System.out.println(arr[i]+"]");
			}else{
				System.out.print(arr[i]+",");
			}
		}
	}
}

选择排序：
思想：遍历数组的元素，拿第一个索引对应的值和后面的元素值进行比较，大的元素值就往前面放，当第一次遍历结束后，最大值就出现在了最小索引处

图解说明：

package cn.edu360;

public class ClassDemo {
	public static void main(String[] args) {
		int[] arr = {2, 4, 11, 0, -4, 333, 90};
		//数组遍历
		showArray(arr);
		selectSort(arr, true);
		showArray(arr);
	}
	
	private static void selectSort(int[] arr, boolean isAsc) {
		//总共需要遍历arr.length-1次
		for (int i = 0; i < arr.length-1; i++) {
			//拿i索引对应的值和后面的元素值进行比较
			for (int j = i+1; j < arr.length; j++) {
				if(isAsc){//升序
					if(arr[i] > arr[j]){//一旦发现后面的元素值小于了前面i对应的元素值时，就将两个索引对应的值进行互换   
						swap(arr, i, j);
					}
				}else{//降序
					if(arr[i] < arr[j]){//一旦发现后面的元素值大于了前面i对应的元素值时，就将两个索引对应的值进行互换   
						swap(arr, i, j);
					}
				}
			}
		}
	}

	private static void swap(int[] arr, int i, int j) {
		int temp = arr[i];
		arr[i] = arr[j];
		arr[j] = temp;
	}
	private static void showArray(int[] arr) {
		for (int i = 0; i < arr.length; i++) {
			if(arr.length == 1){
				System.out.println("["+arr[i]+"]");
			}else if(i == 0){
				System.out.print("["+arr[i]+",");
			}else if(i == arr.length-1 ){
				System.out.println(arr[i]+"]");
			}else{
				System.out.print(arr[i]+",");
			}
		}
	}
}

二、查找
普通查找：

package cn.edu360;

import java.util.Scanner;

public class ClassDemo {
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		System.out.println("请输入您也要查找的值：");
		int key = sc.nextInt();
		int[] arr = {2, 4, 11, 0, -4, 333, 90};
		int location = normalSearchKey(arr, key);
		
		if(location == -1){
			System.out.println("您要查找的元素在该序列中不存在！");
		}else{
			System.out.println("该元素在第"+(location+1)+"个位置");
		}
	}

	private static int normalSearchKey(int[] arr, int key) {
		for (int i = 0; i < arr.length; i++) {
			if(arr[i] == key){
				return i;
			}
		}
		return -1;
	}
}

二分查找：
步骤：

声明两个变量，分别表示开始索引和结束索引
int start = 0;
int end = arr.length-1;
判断开始索引是否小于等于结束索引，如果不满足条件，则结束这个循环，返回-1表示没有找到指定元素key的位置，如果满足计算中间索引值
int middle = (start + end)/2;
拿中间索引对应的值和key做比较，如果两者之间的值相等，则说明中间索引就是我要找的位置
如果key大于了中间索引对应的元素值
降序：end = middle - 1;
升序：start = middle +1;
如果key小于了中间索引对应的元素值
降序：start = middle + 1;
升序：end = middle - 1;
再返回到第二步，整体是用while循环比较合适

package cn.edu360;

import java.util.Scanner;

public class ClassDemo {
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		System.out.println("请输入您也要查找的值：");
		int key = sc.nextInt();
		int[] arr = {2, 4, 11, 0, -4, 333, 90};
		showArray(arr);
		int location = binarySearchKey(arr, key);
		
		if(location == -1){
			System.out.println("您要查找的元素在该序列中不存在！");
		}else{
			System.out.println("该元素在第"+(location+1)+"个位置");
		}
	}
	
	private static int binarySearchKey(int[] arr, int key) {
		//1、声明开始索引和结束索引
		int start = 0;
		int end = arr.length-1;
		
		//2、判断开始索引是否小于等于结束索引
		while (start <= end) {
			//2.1 计算中间索引
			int middle = (start + end)/2;
			//3、比较中间索引对应的值和key的值
			//3.1 如果中间索引对应的元素和key值相等，就直接返回中间索引的值
			if(arr[middle] == key){
				return middle;
			}else if(key > arr[middle]){//key大于中间索引对应的元素值
				if (arr[0] - arr[arr.length-1] < 0) {
					//升序
					start = middle+1;
					//降序
					end = middle-1;
				}
			}else{//key小于中间索引对应的元素值
				if (arr[0] - arr[arr.length-1] < 0) {
					//升序
					end = middle-1;
					//降序
					start = middle+1;
				}
			}
		}
		return -1;
	}

	private static void showArray(int[] arr) {
		for (int i = 0; i < arr.length; i++) {
			if(arr.length == 1){
				System.out.println("["+arr[i]+"]");
			}else if(i == 0){
				System.out.print("["+arr[i]+",");
			}else if(i == arr.length-1 ){
				System.out.println(arr[i]+"]");
			}else{
				System.out.print(arr[i]+",");
			}
		}
	}
}

三、工具类

Arrays这个工具类里面封装了很多对数组操作的方法，比如排序、查找

package cn.edu360;

import java.util.Arrays;

public class ClassDemo {
	public static void main(String[] args) {
		int[] arr = {2, 54, 1, 12, 2, 5};
		System.out.println(Arrays.toString(arr));
		
		//sort方法
		Arrays.sort(arr);
		System.out.println(Arrays.toString(arr));
		
		//binarySearch方法
		int location = Arrays.binarySearch(arr, 5);
		System.out.println(location);
	}
}

包装类
将基本数据类型封装成包装类，可以给基本数据类型提供更多的方法
基本数据类型常见的操作就是和字符串之间进行转换，所以在包装类中都有这个黄钻换的方法
一共8个基本数据类型分别对应着8个包装类
byte—Byte
short—Short
int—Integer
long—Long
float—Float
double—Double
char—Character
boolean—Boolean
图解分析：

代码实现：

package cn.edu360;

public class ClassDemo {
	public static void main(String[] args) {
		//String--->int
		String s = "123";
		int i = Integer.parseInt(s);
		System.out.println(i);
		
		//int--->String
		String s1 = Integer.toString(i);
		System.out.println(s1);
		System.out.println(i+"");
		
		Integer i2 = 123;//JDK1.5新特性：自动装箱
		int i3 = i2;//JDK1.5新特性：自动拆箱
	}
}

☞☞☞Integer包装类

常用的基本进制转换
（1）public static String toBinaryString(int i)
将一个int值转换成二进制字符串表现形式
（2）public static String toOctalString(int i)
将一个int值转换成八进制字符串表现形式
（3）public static String toHexString(int i)
将一个int值转换成十六进制字符串表现形式
代码实现：

package cn.edu360;

public class ClassDemo {
	public static void main(String[] args) {
		test();
	}

	private static void test() {
		int i = 100;
		System.out.println(Integer.toBinaryString(i));//1100100
		System.out.println(Integer.toOctalString(i));//144
		System.out.println(Integer.toHexString(i));//64
	}
}

十进制转换成其他进制
public static String toString(int i,int radix)
将指定值i转换成radix指定的进制数
i—要转换成字符串的整数
radix—要转换成几进制
代码实现：

package cn.edu360;

public class ClassDemo {
	public static void main(String[] args) {
		test();
	}

	private static void test() {
		System.out.println(Integer.toString(100, 2));//1100100
		System.out.println(Integer.toString(100, 8));//144
		System.out.println(Integer.toString(100, 16));//64
	}
}

其他进制转换成十进制
public static int parseInt(String s,int radix)
使用第二个参数指定的基数，将字符串解析为有符号的整数
s—包含要解析的整数表示形式的String
radix—这个字符串是几进制的
代码实现：

package cn.edu360;

public class ClassDemo {
	public static void main(String[] args) {
		test();
	}

	private static void test() {
		String s = "1100100";
		System.out.println(Integer.parseInt(s, 2));//100
		
		s = "144";
		System.out.println(Integer.parseInt(s, 8));//100
		
		s = "64";
		System.out.println(Integer.parseInt(s, 16));//100
	}
}

注意事项：
所有的包装类和对应的基本数据类型都有自动装箱和拆箱的特性，数值类型的包装类都有和字符串相互转换的方法
如：Float.parseFloat(s)；Long.parseLong(s)；Byte.parseByte(s);
☞☞☞Character包装类
Character内部封装了一个基本数据类型char的值，Character内部提供了很多用于字符判断和转换的方法，比如小写转大写，大写转小写；比如判断当前字符是大写还是小写，判断当前的字符是不是数字字符等等方法
（1）public static boolean isUpperCase(char ch)
判断参数字符是不是大写
（2）public static boolean isLowerCase(char ch)
判断参数字符是不是小写
（3）public static boolean isDigit(char ch)
判断参数字符是不是数字
（4）public static char toUpperCase(char ch)
将参数字符转换成大写
（5）public static char toLowerCase(char ch)
将参数字符转换成小写
代码实现：

package cn.edu360;

public class ClassDemo {
	public static void main(String[] args) {
		test();
	}

	private static void test() {
		Character c = 'c';//自动装箱
		char c2 = c;//自动拆箱
		
		System.out.println(Character.isUpperCase(c2));//false
		System.out.println(Character.isLowerCase(c2));//true
		System.out.println(Character.isDigit(c2));//false
		
		System.out.println(Character.toUpperCase(c));//C
		
		System.out.println(Character.toLowerCase('A'));//a
	}
}

☞☞☞BigInteger类
BigInteger类是可以存储int放不下的值
代码实现：

package cn.edu360;

import java.math.BigInteger;

public class ClassDemo {
	public static void main(String[] args) {
		//int的最大值
		int maxValue = Integer.MAX_VALUE;
		System.out.println(maxValue);//2147483647
		
		String s = "2147483648";
		BigInteger bigInteger = new BigInteger(s);
		System.out.println(bigInteger);//2147483648
	}
}

（1）public BigInteger add(BigInteger val)
加法
（2）public BigInteger subtract(BigInteger val)
减法
（3）public BigInteger multiply(BigInteger val)
乘法
（4）public BigInteger divide(BigInteger val)
除法
（5）public BigInteger[] divideAndRemainder(BigInteger val)
返回商和余数
代码实现：

package cn.edu360;

import java.math.BigInteger;

public class ClassDemo {
	public static void main(String[] args) {
		BigInteger bi = new BigInteger("10");
		BigInteger bi2 = new BigInteger("2");
		
		System.out.println(bi.add(bi2));//12
		System.out.println(bi.subtract(bi2));//8
		System.out.println(bi.multiply(bi2));//20
		System.out.println(bi.divide(bi2));//5
		BigInteger[] result = bi.divideAndRemainder(bi2);
		System.out.println("商："+result[0]+",余数："+result[1]);//商：5,余数：0
	}
}

☞☞☞BigDecimal类
由于java中对小数的计算会有精度的损失，所以这时候java就提供了一个类用于计算小数运算的，这个类就是BigDecimal

package cn.edu360;

public class ClassDemo {
	public static void main(String[] args) {
		System.out.println(0.09+0.01);//理想值：0.1        计算结果：0.09999999999999999
		System.out.println(1.0-0.32);//理想值：0.68        计算结果：0.6799999999999999
		System.out.println(1.015*100);//理想值：101.5      计算结果：101.49999999999999
		System.out.println(1.301/100);//理想值：0.01301    计算结果：0.013009999999999999
	}
}

通常使用的构造方法
public BigDecimal(String val)：将一个字符串小数形式转换成一个BigDecimal对象
成员方法
（1）public BigDecimal add(BigDecimal augend)加法
（2）public BigDecimal subtract(BigDecimal subtrahend)减法
（3）public BigDecimal multply(BigDecimal multiplicand)乘法
（4）public BigDecimal divide(BigDecimal divisor)除法
（5）public BigDecimal divide(BigDecimal divisor,int scale,int roundingMode)除法
其中：scale：保留的小数位数；roundingMode：舍入的模式
代码实现：

package cn.edu360;

import java.math.BigDecimal;

public class ClassDemo {
	public static void main(String[] args) {
//		System.out.println(0.09+0.01);//理想值：0.1        计算结果：0.09999999999999999
//		System.out.println(1.0-0.32);//理想值：0.68        计算结果：0.6799999999999999
//		System.out.println(1.015*100);//理想值：101.5      计算结果：101.49999999999999
//		System.out.println(1.301/100);//理想值：0.01301    计算结果：0.013009999999999999
		
		BigDecimal bd = new BigDecimal("0.09");
		BigDecimal bd2 = new BigDecimal("0.01");
		System.out.println(bd.add(bd2));//0.10
		
		bd = new BigDecimal("1.0");
		bd2 = new BigDecimal("0.32");
		System.out.println(bd.subtract(bd2));//0.68
		
		bd = new BigDecimal("1.015");
		bd2 = new BigDecimal("100");
		System.out.println(bd.multiply(bd2));//101.500
		
		bd = new BigDecimal("1.301");
		System.out.println(bd.divide(bd2));//0.01301
		
		//scale：保留的小数位数
		//roundingMode：舍入的模式
		System.out.println(bd.divide(bd2, 2, BigDecimal.ROUND_HALF_UP));
	}
}

四、Math类
Math类里面封装了一些常用的数学公式
一些基本方法：

public static int abs(int a)
返回int的绝对值
public static double ceil(double a)
返回最小的（最接近负无穷大）double值，该值大于等于参数，并等于某个整数
public static double floor(double a)
返回最大的（最接近正无穷大）double值，该值小于等于参数，并等于某个整数
public static double pow(double a,double b)
返回第一个参数以第二个参数为次方的值
public static double random()
返回带正号的double值，该值大于等于0.0且小于1.0
public static int round(float a)
返回最接近参数的int
public static double sqrt(double a)
开a的平方根
代码实现：

package cn.edu360;

public class ClassDemo {
	public static void main(String[] args) {
		System.out.println(Math.abs(-18));//18
		System.out.println(Math.ceil(12.12));//13.0
		System.out.println(Math.floor(12.12));//12.0
		System.out.println(Math.pow(2, 3));//8.0
		System.out.println(Math.random());//0.3530568432413479
		System.out.println(Math.round(12.4));//12
		System.out.println(Math.sqrt(64));//8.0
	}
}

五、Random类
Random是用于产生随机数

构造函数
public Random()
是使用默认种子产生的随机数
public Random(long seed)
使用我们自己给的一种种子用于生产随机数，使用相同种子每次生产的随机数都是一样的
成员方法
puiblic int nextInt()
下一个伪随机数，它是此随机数生成器的序列中均匀分布的int值

package cn.edu360;

import java.util.Random;

public class ClassDemo {
	public static void main(String[] args) {
		Random r = new Random();
		System.out.println(r.nextInt());//产生的是一个随机值，有2^32中可能性
		
		Random r1 = new Random(10);
		Random r2 = new Random(10);
		
		//下面两值是相同的
		System.out.println(r1.nextInt());
		System.out.println(r2.nextInt());
	}
}

public int nextInt(int n);返回的都是整数，而且范围是0~（n-1）
代码实现：

package cn.edu360;

import java.util.Random;

public class ClassDemo {
	public static void main(String[] args) {
		Random r = new Random();
		int i = r.nextInt(5);
		System.out.println(i);
	}
}

六、System类
System类里面包含了一些字段和方法，System类不能被实例化

public static void gc()
运行垃圾回收器
public static void exit(int statuc)
终止当前正在运行的Java虚拟机，参数用作状态码，根据管理，非0的状态码表示异常终止
public static long currentTimeMillis()
当前时间与协调世界时1970年1月1日午夜之间的时间差（以毫秒为单位测量）
public static void arraycopy(Object src,int srcPos,Object dest,int destPos,int length)
从指定源数组中赋值一个数组
src—>源数组
srcPos—>源数组中的起始位置
dest—>目标数组
destPos—>目标数组中的起始位置
length—>要复制的数组元素的数量
代码实现：

package cn.edu360;

import java.util.Arrays;

public class ClassDemo {
	public static void main(String[] args) {
//		System.exit(-1);
//		System.out.println("哈哈");
		
		System.out.println(System.currentTimeMillis());//1543130523938
		
		int[] src = {1, 2, 3, 4, 5, 6};
		int srcPos = 1;
		int[] dest = new int[5];
		int destPos = 1;
		int length = 3;
		System.arraycopy(src, srcPos, dest, destPos, length);
		System.out.println(Arrays.toString(dest));//[0, 2, 3, 4, 0]
	}
}

七、Date类
表示特定的瞬间，精确到毫秒

public Date()
分配Date对象并初始化对象，以表示分配它的时间（精确到毫秒）
public Date(long date)
将现有的毫秒值封装成一个日期对象
public long getTime()
返回自1970年1月1日00:00：00GMT以来Date对象表示的毫秒数
public void setTime(long time)
设置此Date对象，以表示1970年1月1日00:00：00GMT以后time毫秒时间点
代码实现：

package cn.edu360;

import java.util.Date;

public class ClassDemo {
	public static void main(String[] args) {
		Date d = new Date();
		System.out.println(d.getTime());//1543131764765
		
		long time = d.getTime();
		Date d2 = new Date(time);
		System.out.println(d.getTime() == d2.getTime());//true
		
		d.setTime(System.currentTimeMillis()+3*60*1000);
	}
}

综上所述：我们发现不论是Date形式的日期还是毫秒值像是的日期我们都看不懂，所以java就提供了日期格式化类：SimpleDateFormat
八、SimpleDateFormat类
DateFormat是格式化日期的抽象类，里面有抽象方法不能直接使用，所以用其子类格式化日期SimpleDateFormat；
SimpleDateFormat是一个以与语言环境有关的方式来格式化和解析日期的具体类。它允许进行格式化（日期—>文本）、解析（文本—>日期）和规范化

构造方法
public SimpleDateFormat()使用默认的模板（根据操作系统决定）创建一个格式化日期类的对象
public SimpleDateFormat(String pattern)用给定的模式和默认语言环境的日期格式构造SimpleDateFormat
成员方法
public final String format(Date date)将一个Date格式化为日期/时间字符串
public Date parse(String source)从给定字符串的开始解析文本，以生成一个日期
代码实现：

package cn.edu360;

import java.text.SimpleDateFormat;
import java.util.Date;

public class ClassDemo {
	public static void main(String[] args) throws Exception {
		//格式化（日期--->文本）
		test();
		//解析（文本--->日期）
		test2();
	}

	private static void test2() throws Exception {
		String s = "18-11-25 下午3:55";
		//将字符串日期s转换成Date对象
		//你使用的是哪一个模板进行格式化的，那么就要用这个模板将字符串日期再解析
		SimpleDateFormat sdf = new SimpleDateFormat();
		System.out.println(sdf.parse(s));//Sun Nov 25 15:55:00 CST 2018
		
		s = "2018--11--25 15:57:47";
		SimpleDateFormat sdf2 = new SimpleDateFormat("yyyy--MM--dd HH:mm:ss");//Sun Nov 25 15:57:47 CST 2018
		System.out.println(sdf2.parse(s));
	}

	private static void test() {
		SimpleDateFormat sdf = new SimpleDateFormat();
		Date d = new Date();
		System.out.println(sdf.format(d));//18-11-25 下午3:55
		
		//自定义显示模板
		SimpleDateFormat sdf2 = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
		System.out.println(sdf2.format(d));//2018-11-25 15:57:47
	}
}

注意事项：在解析的过程中，你使用的是哪一个模板进行格式化的，那么就要用这个模板将字符串日期再解析