选择排序-二分查找-Arrays-System-BigDecimal-BigInteger-Date-Calendar-Math

最新推荐文章于 2022-12-04 21:58:35 发布
最新推荐文章于 2022-12-04 21:58:35 发布
阅读量297 收藏
点赞数
分类专栏： JavaSE基础 文章标签： 二分查找
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Luna_ll/article/details/78456003
版权

一.选择排序

1.思想：从0索引开始，用它对应的元素依次和后面索引对应的元素进行比较，小的往前放，第一次比较完毕，最小值出现在了最小索引处，依次这样比较，就可以得到一个从小到达排好序的数组。

package day_12_11_6.sort;

public class SelectSort {
	
	public static void main(String[] args) {
		// 定义并初始化一个数组
		int arr[] = {12,3,6,4,1};
		//打印数组
		System.out.println("排序前:");
		printArray(arr);
		//选择排序
		selectSort(arr);
		System.out.println("排序后:");
		printArray(arr);
	}
	
	//打印数组的功能
	public static void printArray(int [] arr){
		System.out.print("[");
		//遍历数组
		for(int i=0;i<arr.length;i++){
			
			//判断是否是最大索引
			if(i==arr.length-1){
				System.out.println(arr[i]+"]");
			}else{
				System.out.print(arr[i]+", ");
			}
		}
		
	}
	//选择排序
	public static void selectSort(int [] arr){
		for(int i=0;i<arr.length-1;i++){	   //排序的次数
			for(int j=i+1;j<arr.length;j++){   //
				//判断,后面的索引对应的元素小于前面索引对应的元素,互换
				if(arr[j]<arr[i]){
					int temp = arr[i];
					arr[i] = arr[j];
					arr[j] = temp;
				}
			}
		}
		
	}
}

二.二分查找

前提条件：数组必须是有序的（即是一个排好序的数组）

思想：猜想中间索引，这样可以将数组减半

步骤：1)一个排好序的数组                                                                                                                                                                2)定义最小索引和最大索引

   3)计算中间索引 int mid = (min+max)/2
   4)拿中间索引对应的元素和要查找的元素进行比较，相等，直接返回中间索引。不相等：大了左边找。小了：右边找
           5)重新获得最小索引和最大索引，大了：int max = mid-1;小了：int min = max+1
           6)回到4)继续找 
package day_12_11_6.sort;
/**
 * 定义一个排好序的数组:
 * 			11,22 ,33 ,44 ,55 ,66 ,77 
 * 查找22元素对应的索引
 * */
public class BinSort {
	public static void main(String[] args) {
		
		// 定义一个数组并静态初始化
		int [] arr = {11,22,33,44,55,66,77};
		
		//需求：查找元素22对应的索引
		int index = getIndex(arr,22);
		System.out.println("index = "+index);

	}
	/**
	 * 两个明确:
	 * 明确返回值类型:int类型
	 * 明确参数类型,几个参数:int[] arr,int value
	 */
	public static int getIndex(int [] arr,int value){
		//定义最小索引和最大索引
		int max = arr.length - 1; 
		int min = 0;
		
		//计算中间索引
		int mid = (max+min)/2;
		
		//中间索引对应的元素和要查找的元素进行比较，不知道比较的次数，用while循环
		while(arr[mid]!=value){
		//当前mid索引对应的元素不等于value元素,分两种情况
			if(arr[mid]>value){
				max = mid - 1;
			}else if(arr[mid]<value){
				min = mid + 1;
			}
			
			//如果找不到了应该返回-1
			if(min>max){
				return -1;
			}
			
			//重新获得最大索引和最小索引，计算中间索引
			mid = (max+min)/2;
		}
		//如果直接相等,直接返回
		return mid;		
	}
}
练习：假设有一个数组，int arr [24,69,80,57,13] ，查找80这个元素在数组中的索引
分析：经过排序算法排序后，数组的索引已经发生变化了，所以遇到这种情况,就不要使用二分查找,就是用最基本的查找方法(从头查到尾) 
public class InsSort {
	public static void main(String[] args) {
		// 定义一个数组并初始化
		int [] arr = {24,69,80,57,13};
		
		//调用获取索引的方法
		int index = getIndex(arr,80);
		System.out.println("index = "+index);
		
	}
	public static int getIndex(int [] arr,int value){
		//假设法：定义一个索引：假设查不到
		int index = -1;
		//遍历数组
		for(int i=0;i<arr.length;i++){
			//判断：如果刚好查到的i索引对应的元素和value相等,那么返回该索引
			if(arr[i]==value){
				//表示查到了,给索引重新赋值
				index = i;
				break;
			}
		}
		return index;
	}		
}

三.数组工具类Arrays

1.常用方法：

1)public static String toString(int[] a):将任意类型的数组以字符串形式显示出来!
2)public static void sort(int[] a):快速排序:(将给定数组中元素升序排序)
3)public static int binarySearch(int[] a, int key):当前int数组一定是有序数组,使用二分搜索法来搜索指定的 int 型数组，以获得指定的值 
public class ArraysDemo {

	public static void main(String[] args) {
		// 定义一个数组
		int[] arr = {24,69,80,57,13};
		//将数组转换成字符串的形式
		/**
		 * 1.public static String toString(int[] a):将任意类型的数组以字符串形式显示出来!
		 * */
		System.out.println("toString():"+Arrays.toString(arr));  //[24, 69, 80, 57, 13]
		
		
		/**
		 * 2.public static void sort(int[] a):快速排序:(将给定数组中元素升序排序)
		 * */
		Arrays.sort(arr);
		//再调用Arrays.toString(int[] a)将排好序的数组以String形式显示出来
		System.out.println("sort():"+Arrays.toString(arr));  //[13, 24, 57, 69, 80]
		
		/**
		 * 3.public static int binarySearch(int[] a, int key):
		 * */
		System.out.println("binarySearch(int[] a, int key):"+Arrays.binarySearch(arr, 69));//3
	}

}
练习：字符串中的字符进行排序。举例："dacgebf"，结果："abcde 

public class ArraysTest {

	public static void main(String[] args) {
		// 创建键盘录入对象
		Scanner sc = new Scanner(System.in);
		
		//录入并接收字符串
		System.out.println("请输入字符串：");
		String s = sc.nextLine();
		
		//将字符串转换成字符数组
		char[] chs = s.toCharArray();
		//对字符数组调用Arrays类sort()方法进行排序
	    Arrays.sort(chs);
	    //将字符数组转换成字符串
	    //方法1:
	    String result = String.valueOf(chs);
	    //方法2：
	    //String result = Arrays.toString(chs);
	    System.out.println("result:"+result);

	}
}
四.BigDecimal类

1.概述：对于浮点类型的数据来说，他们的存储和整数的存储是不一致的，是按照有效数字位来进行存储的，浮点类型的数据计算的时候容易损失精度，计算出来的结果不精确，Java针对 这个情况，提供BigDecimal。

作用：来提供浮点类型数据的精确计算！可变的、任意精度的有符号十进制数

构造方式：public BigDecimal(String val)
成员方法：
1)public BigDecimal add(BigDecimal augend):加
2)public BigDecimal subtract(BigDecimal subtrahend):减
3)public BigDecimal multiply(BigDecimal multiplicand):乘法
4)public BigDecimal divide(BigDecimal divisor):除
5)public BigDecimal divide(BigDecimal divisor,int scale,int roundingMode)参数1:除数,参数2:保留几位小数,参数3:舍入的一种模式:ROUND_HALF_UP 
package day_12_11_6.BigDecimal;

import java.math.BigDecimal;

public class BigDecimalDemo {
	public static void main(String[] args) {
		/*System.out.println(1.0-0.32);		//0.6799999999999999
		System.out.println(0.01+0.09);		//0.09999999999999999
		System.out.println(1.501*100);		//150.1
		System.out.println(1.031/100);		//0.01031
		*/	
		//创建BigDecimal对象
		BigDecimal bd1 = new BigDecimal("0.01") ;
		BigDecimal bd2 = new BigDecimal("0.09") ;
				
		//public BigDecimal add(BigDecimal augend):加
		System.out.println("add:"+bd1.add(bd2));
				
		BigDecimal bd3 = new BigDecimal("1.0") ;
		BigDecimal bd4 = new BigDecimal("0.32") ;
				
		//public BigDecimal subtract(BigDecimal subtrahend):减
		System.out.println("sub:"+bd3.subtract(bd4));//0.68
				
		//public BigDecimal multiply(BigDecimal multiplicand):乘法
		BigDecimal bd5 = new BigDecimal("1.501") ;
		BigDecimal bd6 = new BigDecimal("100.0") ;
		System.out.println("mul:"+bd5.multiply(bd6));
				
		//public BigDecimal divide(BigDecimal divisor):除
		BigDecimal bd7 = new BigDecimal("1.301") ;
		BigDecimal bd8 = new BigDecimal("100") ;
				
		System.out.println("div:"+bd7.divide(bd8));
		//public BigDecimal divide(BigDecimal divisor,int scale,int roundingMode)
		//参数1:商,	参数2:保留几位小数,参数3:舍入的一种模式:ROUND_HALF_UP
				
	       System.out.println("div:"+bd7.divide(bd8, 3, BigDecimal.ROUND_HALF_UP));
	       System.out.println("div:"+bd7.divide(bd8, 8, BigDecimal.ROUND_HALF_UP));	
	}
}

五.BigInteger类：

1.概述：用来计算超出了Integer类型范围的数据。
2.构造方式：public BigInteger(String var):将字符串封装成BigInteger类型 
package day_12_11_6.BigInteger;

import java.math.BigInteger;

public class BigIntegerDemo {

	public static void main(String[] args) {
		// 查看Integer类的最大值
		System.out.println(Integer.MAX_VALUE);//2147483647

		/*//创建Integer对象
		Integer i = new Integer("2147483648");
		System.out.println(i);		//java.lang.NumberFormatException: For input string: "2147483648",数据超出Integer范围
		*/
		//创建BigInteger对象
		BigInteger bi = new BigInteger("2147483648");
		System.out.println(bi);
	}

}

3.成员方法：

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):返回一个BigInteger数组,数组中的元素:商,余数 
package day_12_11_6.BigInteger;
import java.math.BigInteger;
public class BigIntegerDemo2 {

	public static void main(String[] args) {
		// 创建BigInteger对象
		BigInteger b1 = new BigInteger("100");
		
		BigInteger b2 = new BigInteger("50");
		System.out.println("add:"+b1.add(b2));
		System.out.println("subtract:"+b1.subtract(b2));
		System.out.println("multiply:"+b1.multiply(b2));
		System.out.println("divide:"+b1.divide(b2));
		
		BigInteger[] datas = b1.divideAndRemainder(b2);
		System.out.println("divideAndRemainder:"+datas[0]);
		System.out.println("divideAndRemainder:"+datas[1]);
	}
}

六.System类

1.概述：该类没有构造方法，所以字段和成员方法都用静态修饰

常用的两个字段：in out都和流有关系：java.io
PrintStream(字节打印流)   ps = System.out; 标准输出流（写数据）
PrintWriter(字节打印流)    
InputStream in = System.in:标准输入流（读数据）
2.常用的成员方法：
1)public static void gc()运行垃圾回收器：调用 gc 方法暗示着 Java 虚拟机做了一些努力来回收未用对象，以便能够快速地重用这些对象当前占用的内存,最终调用的就是重写之后finalize()回收不用的对象! 
package day_12_11_6.system;

public class SystemDemo {
	public static void main(String[] args) {
		// 创建Person对象
		Person p = new Person("高圆圆",27);
		System.out.println(p);
		p = null;	//当前Person变成空了,没有更多的引用了
		//启动垃圾回收器
		System.gc();//当前垃圾回收器需要回收不用对象了Person [name=高圆圆, age=27]
	}
}

package day_12_11_6.system;

public class Person {
	
		private String name;
		private int age;
		
		public Person() {
			super();
			// TODO Auto-generated constructor stub
		}
		
		public Person(String name, int age) {
			super();
			this.name = name;
			this.age = age;
		}

		public String getName() {
			return name;
		}

		public void setName(String name) {
			this.name = name;
		}

		public int getAge() {
			return age;
		}

		public void setAge(int age) {
			this.age = age;
		}

		@Override
		public String toString() {
			return "Person [name=" + name + ", age=" + age + "]";
		}		
}
2)public static void arraycopy(Object src,int srcPos,Object dest, int destPos,int length)
指定源数组中复制一个数组，复制从指定的位置开始，到目标数组的指定位置结束 
package day_12_11_6.system;

import java.util.Arrays;
public class SystemDemo2 {
	public static void main(String[] args) {
		// 定义两数组，静态初始化
		int [] arr1 = {11,22,33,44,55};
		int [] arr2 = {1,2,3,4,5};
		
		//复制数组
		System.arraycopy(arr1, 1, arr2, 2, 3);
		
		//分别将arr1 和arr2数组以字符串形式显示出来
		System.out.println("arr1:"+Arrays.toString(arr1));
		System.out.println("arr2:"+Arrays.toString(arr2));
	}
}
3)public static void exit(int status)终止当前正在运行的 Java 虚拟机。参数用作状态码；根据惯例，非 0 的状态码表示异常终止。
4)public static long currentTimeMillis():返回当前的时间毫秒值 
package day_12_11_6.system;

public class SystemTest {

	public static void main(String[] args) {
		//输出语句
		System.out.println("I want to travel!");

		//调用exit()方法
		//System.exit(0);  //JVM已经退出了,还可结束循环语句,调用该方法Jvm都退出了,所以循环也就结束了
		System.out.println("but you must have enough money!");
		
		//单独使用
		long time = System.currentTimeMillis(); //获取当前系统时间毫秒值
		System.out.println(time);
		
		//currentTiimeMillis():单独使用没意义
		//需求:计算某一个应用程序的耗时的毫秒数
		long start = System.currentTimeMillis() ;
		//for循环
		for(int x = 0 ; x <100000;x ++){
			System.out.println("hello"+x);
		}
				
		long end = System.currentTimeMillis() ;
				
		System.out.println("当前for循环语句共耗时:"+(end-start)+"毫秒");//前for循环语句共耗时:1556毫秒	
	}
}

七.Calender类(日历类)：

1.概述：Calendar是一个抽象类，它为特定瞬间与一组诸如 YEAR、MONTH、DAY_OF_MONTH、HOUR 等 日历字段之间的转换提供了一些方法，并为操作日历字段（例如获得下星期的日期）提供了一些方法
2.Calendar该类是一个抽象类:不能实例化的,所以通过以下这个方法来创建对象：public static Calendar getInstance()
3.public int get(int field)返回给定日历字段的值
4.日历字段值：
1)public static final int YEAR:表示日历中的年
2)public static final int MONTH:月份:是0开始计算的
        3)public static final int DATE:和DAY_OF_MONTH是同义词,表示月份中的某天 

package day_12_11_6.calendar;
import java.util.Calendar;
public class CalendarDemo {

	public static void main(String[] args) {
		//创建日历对象
		Calendar c = Calendar.getInstance();
		//获取年
		int year = c.get(Calendar.YEAR);
		//获取月
		int month = c.get(Calendar.MONTH);
		//获取日
		int date = c.get(Calendar.DATE);
		
		System.out.println(year+"年"+(month+1)+"月"+date+"日");
	}
}

5.成员方法：
public abstract void add(int field,int amount)：为给定的日历的字段添加或者减去时间偏移量 
public final void set(int year,int month,int date)：设置日历字段 YEAR、MONTH 和 DAY_OF_MONTH 的值 
package day_12_11_6.calendar;

import java.util.Calendar;
public class CalendarDemo2{
	public static void main(String[] args) {
		// 创建日历类对象
		Calendar c = Calendar.getInstance();
		
		//获取年
		int year = c.get(Calendar.YEAR);
		//获取月
		int month = c.get(Calendar.MONTH);
		//获取月中的天
		int date = c.get(Calendar.DATE);
		System.out.println(year+"年"+(month+1)+"月"+date+"日");
		
		
		//public abstract void add(int field,int amount)
		c.add(Calendar.YEAR, -3);
		//获取年
		 year = c.get(Calendar.YEAR);
		//获取月
	     month = c.get(Calendar.MONTH);
		//获取月中的天
		 date = c.get(Calendar.DATE);
		System.out.println(year+"年"+(month+1)+"月"+date+"日");
		
		//需求：十年后的五天前
		c.add(Calendar.YEAR, 10);
		c.add(Calendar.DATE, -5);
		//获取年
		 year = c.get(Calendar.YEAR);
		//获取月
	     	month = c.get(Calendar.MONTH);
		//获取月中的天
		 date = c.get(Calendar.DATE);
		System.out.println(year+"年"+(month+1)+"月"+date+"日");
		
		//public final void set(int year, int month, int date)
		c.set(2018, 5, 10);
		//获取年
		 year = c.get(Calendar.YEAR);
		//获取月
	     	month = c.get(Calendar.MONTH);
		//获取月中的天
		 date = c.get(Calendar.DATE);
		System.out.println(year+"年"+(month+1)+"月"+date+"日");	
	}
}
练习：键盘录入一个年份,获取任意一年的二月有多少天 
package day_12_11_6.calendar;

import java.util.Calendar;
import java.util.Scanner;

public class CalendarTest {

	public static void main(String[] args) {
		// 创建键盘录入对象
		Scanner sc = new Scanner(System.in);
		
		//录入并接收数据
		System.out.println("请输入一个年份");
		int year = sc.nextInt();
		
		//创建日历类对象
		Calendar c = Calendar.getInstance();
		
		//设置日历的字段，年，月，日
		c.set(year, 2, 1);//其实月份:(month+1):3月1
		//将时间往前推算一天
		c.add(Calendar.DATE, -1);
		System.out.println(year+"年2月有："+c.get(Calendar.DATE));
	}
}

八.Date类（日期类）
1.概述：表示特定的瞬间，精确到毫秒
2.常用的构造方式：
1)public Date():表示分配的一个Date对象：无参：获取当前系统的时间
2)public Date(long date):指定一个时间毫秒值 和它1970-1-1 00:00:00有时间差 
package day_12_11_6.date;

import java.util.Date;

public class DateDemo {

	public static void main(String[] args) {
		// 创建日期对象
		Date d = new Date();
		
		//输出日期对象
		System.out.println("d:"+d);//Mon Nov 06 20:01:33 GMT+08:00 2017
		
		//设置一个时间long
		long time = 1000/60/60;
		Date d2 = new Date(time);
		System.out.println("d2:"+d2);//Thu Jan 01 08:00:00 GMT+08:00 1970

	}
}

3.成员方法

1)public long getTime():获取当前时间毫秒值:如果知道Date对象,可以通过getTime()获取时间毫秒值
2)public void setTime(long time) 
package day_12_11_6.date;

import java.util.Date;

public class DateDemo2 {
	public static void main(String[] args)
		// 创建一个日期对象
		Date d = new Date();
		System.out.println(d);
		
		//public long getTime():获取当前时间毫秒值
		long time = d.getTime();
		System.out.println(time);
		System.out.println(System.currentTimeMillis());//通过System可以获取当前时间的毫秒数
		
		//public void setTime(long time)
		d.setTime(1000);
		System.out.println(d);
	}
}

九.日期工具类

1.将Date对象--->String类型的日期的"文本格式":格式化：public final String format(Date date)
2.String类型日期的"文本格式"---->Date日期对象:解析：public Date parse(String source) 该方法本身会抛出一个异常:ParseException(解析异常:编译时期异常)
3.要进行转换:必须使用中间桥梁:DateFormat 是日期/时间格式化子类的抽象类，它以与语言无关的方式格式化并解析日期或时间。
日期/时间格式化子类（如 SimpleDateFormat）允许进行格式化（也就是日期Date -> 文本String）、解析（文本String-> 日期Date）和标准化
4.但是，DateFormat是抽象类,不能直接实例化,使用的是它更具体的子类进行实例化:SimpleDateFormat 是一个以与语言环境有关的方式来格式化和解析日期的具体类
5.构造方法：public SimpleDateFormat(String pattern)用给定的模式和默认语言环境的日期格式符号构造 SimpleDateFormat
6.日期和时间模式：
y 年 比如:2017---->yyyy
M 年中的月份:2------>MM
d  月份中的天数 :----->dd
H 小时 HH
m 小时中的分钟数 mm
s 分钟中的秒数 ss
 
package day_12_11_6.date;

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

public class DateUtil {
	//将无参构造私有化，为了不让外界创建对象
	private DateUtil() {
		
	}
	/**
	 * Date--->String格式化
	 * */
	public static String dateToString(Date d,String format){
		//创建SimpleDateFormat对象
		SimpleDateFormat sdf = new SimpleDateFormat(format);
		//格式化
		String str = sdf.format(d);
		return str;
	}
	/**
	 *将String的日期"文本格式"解析成一个Date日期对象
	 * @throws ParseException 
	 * */
	public static Date stringToDate(String s,String format) throws ParseException{
		//SimpleDateFormat对象
		SimpleDateFormat sdf = new SimpleDateFormat(format) ;
		Date date = sdf.parse(s);
		return date;
	}
	
}

package day_12_11_6.date;

import java.text.ParseException;
import java.util.Date;
import java.util.Scanner;

public class DateUtilDemo {

	public static void main(String[] args) throws ParseException {
		// Date--->String
		//创建一个Date对象
		Date d = new Date();
		
		//调用格式化功能
		String str = DateUtil.dateToString(d, "yyyy-MM-dd HH:mm:ss");
		System.out.println("str:"+str);
		
		//String str2 = DateUtil.dateToString(d, "yyyy-MM-dd");
		//System.out.println("str2:"+str2);
		
		//String--->Date
		//模式要和字符串文本格式一致
		String s = "2018-10-1 12:34:56";
		//调用功能
		Date date = DateUtil.stringToDate(s, "yyyy-MM-dd HH:mm:ss");
		System.out.println("date:"+date);
	}

}

练习：键盘录入你的出生年月日,计算你来到这个世界有多少天了? 
package day_12_11_6.date;

import java.text.ParseException;
import java.util.Date;
import java.util.Scanner;

public class MyLifeTest {

	public static void main(String[] args) throws ParseException {
		// 创建键盘录入对象
		Scanner sc = new Scanner(System.in);
		//录入并接收数据
		System.out.println("请输入出生年月日：yyyy-MM-dd");
		String s = sc.nextLine();
		
		//使用DateUtil工具类
		Date date = DateUtil.stringToDate(s, "yyyy-MM-dd");
		//获取出生年月的时间毫秒值
		long oldTime = date.getTime();
		
		//获取当前系统的时间毫秒值
		long newTime = System.currentTimeMillis();
		
		long time = newTime - oldTime;
		//将毫秒值换算成天
		long day = time/1000/60/60/24;
		//输出
		System.out.println("你已出生"+day+"天啦");
	}
}
十.Math类
常用的成员方法:
1.public static int abs(int a):绝对值
2.public static double ceil(double a):向上取整
3.public static double floor(double a):向下取整
4.public static double max(double a,double b):获取最大值
5.public static double min(double a,double b):获取最小值
6.public static double pow(double a,double b):a的b次幂
7.public static double random():取值范围:[0.0,1.0)
8.public static long round(double a):四舍五入
9.public static double sqrt(double a):一个数的正平方跟 
package day_12_11_6.math;

public class MathDemo {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		System.out.println(Math.abs(-100));
		
		//public static double ceil(double a):向上取整
		System.out.println("ceil:"+Math.ceil(12.34));//13.0
		System.out.println("ceil:"+Math.ceil(12.54));//13.0
		
		//public static double floor(double a):向下取整	
		System.out.println("floor:"+Math.floor(12.34)); //12.0
		System.out.println("floor:"+Math.floor(12.56)); //12.0
		
		//public static double max(double a,double b):获取最大值
		System.out.println("max:"+Math.max(Math.max(10,20),30));
		
		//public static double pow(double a,double b):a的b次幂
		System.out.println("pow:"+Math.pow(2, 3));
		
		//public static long round(double a):四舍五入
		System.out.println("round:"+Math.round(12.56));//13
		
		//public static double sqrt(double a):一个数的正平方跟
		System.out.println("sqrt:"+Math.sqrt(4));
		
		//public static double random():取值范围:[0.0,1.0)
		System.out.println("random:"+(int)(Math.random()*10));
		
	}
}




Luna_ll
关注
专栏目录
13.Java-数组高级冒泡排序、高级选择排序、直接插入排序、快速排序、基数排序、二分查找
qq_39004315的博客
12-11 149
13.Java-数组高级冒泡排序 一、数组高级冒泡排序原理图解 A:画图演示 需求： 数组元素：{24, 69, 80, 57, 13} 请对数组元素进行排序。 B:冒泡排序原理 相邻元素两两比较，大的往后放，第一次完毕，最大值出现在了最大索引处 二、数组高级冒泡排序代码实现 package org.westos.java12; /*A:画图演示 需求： 数组元素：{24, 69, 80, 57, 13} 请对数组元素进行排序。
StringBuffer、StringBuiler、包装类、Integer、BigInteger、BigDecimal、Math、System、Date、Calendar
m0_45209551的博客
03-14 661
一 回顾 1.项目打包 导包 删除依赖包 2.Object 概念:Object的所有类的直接父类或者是间接父类 构造:public Object() 常用的方法: public String toString() A.返回对象的字符串表示形式 B.没有重写返回的是对象的地址值 重写之后返回的是对象的属性值 public boolean equals(Object obj) A.比较两个对象是否是同一个对象 两个栈引......
[JavaSE]（BigDecimal，包装类、装箱、拆箱、二分查找、冒泡排序、递归）
沫洺的博客
08-13 468
BigDecimal，包装类、装箱、拆箱、二分查找、冒泡排序、递归。
leetcode刷题之二分查找
qq_39621037的博客
10-29 414
第一个错误的版本 参考代码 //使用查到第一个满足某条件的模板 // Forward declaration of isBadVersion API. bool isBadVersion(int version); class Solution { public: int firstBadVersion(int n) { int left=1,right=n; ...
java中关于Arrays.sort()的三种用法
qq_33098049的博客
08-11 3万+
Java的Arrays类中有一个sort()方法，该方法是Arrays类的静态方法，在需要对数组进行排序时，非常的好用。 但是sort()的参数有好几种，下面我就为大家一一介绍，这几种形式的用法。 1、Arrays.sort(int[] a) 这种形式是对一个数组的所有元素进行排序，并且是按从小到大的顺序。 举例如下（点“+”可查看代码）： 1 import java.util.Ar...
深入理解Arrays.sort()
weixin_34253539的博客
11-16 896
翻译人员: 铁锚 翻译日期: 2013年11月16日 原文链接:Deep Understanding of Arrays.sort(T[], Comparator < ? super T > c) Arrays.sort(T[], Comparator < ? super T > c) 方法用于对象数组按用户自定义规则排序. 官方Java文档只是简...
Java-BigInteger，BigDecimal，Arrays，包装类，String类
人生起落，生活苦甜，坚持追求！
03-07 560
回顾 Object类 toString: 默认返回包名.类名@地址值,重写之后返回对象的内容 equals: 默认比较两个对象的地址值,重写之后比较对象的内容 Date类: public Date(); 当前时间 public Date(long millis);距离基准时间millis毫秒后的那个时间 DateFormat类: public Sim...
华清远见-重庆中心-JAVA高级阶段知识点梳理
最新发布
weixin_52590383的博客
12-04 613
Java高级
javaSE第五章_＜API常用类(2)＞【替换,正则表达式,StringBuffer类,Random类,System类,Date-Calendar,BigInteger_BigDecimal】
SDWESCES的博客
03-20 512
文章目录替换功能正则表达式 替换功能 正则表达式 正则 表达式 规则 是一种字符串模式匹配语言 指定规则：手机号规则 注册手机号 手机号 15111111111 11位 数字 以1开头 ---格式 邮箱 wrwuert7254632@re23.com */ /*Scanner s=new Scanner(System.in); System.out.println("请输入手机号"); String phone=s.next(); */
JAVA 基础知识整理-10正则表达式Regex, Pattern类，Matcher类，Math类，System类~Calendar类
KathyLJQ的博客
03-05 380
1.正则表达式 boolean matches(String regex) 告诉这个字符串是否匹配给定的 regular expression 。 构造 匹配 字符 x 字符 x \ 反斜线字符 \0n 带有八进制值 0n 的字符(0 <= n <= 7) \0nn 带有八进制值 0nn 的字符(0 <= n <= 7) \0mnn 带...
Arrays.sort()的用法
龙之竹的博客
04-08 6212
1、Arrays.sort(int[] a)对数组进行从小到大排序，默认字典序排序（ASCII）2、Arrays.sort(int[] a, int fromIndex, int toIndex)对数组的a[fromIndex,toIndex-1]排序3、public static &lt;T&gt; void sort(T[] a,int fromIndex,int toIndex, Compa...
[code]二分法:从已排好序的String数组中查询要搜索的字符串的下标
ProgrammingRoad
05-07 2724
package utils.find;import java.lang.reflect.Array;/** * ArrayUtil * Generated on: 2010.05.07 * * @author loocao */public class ArrayUtil { /** * @param args */ public stati
Arrays.sort()的用法（对二维数组进行排序）。
weixin_42632962的博客
12-17 1万+
四个方法： sort(T[] a)：对指定数组进行升序排列。 sort(T[] a,int formIndex, int toIndex)：对指定数组的指定范围升序排列。 sort(T[] a, Comparator<? supre T> c): 根据指定比较器产生的顺序对指定对象数组进行排序。 sort(T[] a, int formIndex, int toIndex, Comparator<? supre T> c): 根据指定比较器产生的顺序对指定对象数组的指定范围进
Arrays.sort(）方法学习
等哈哆
01-20 314
之前看了这个方法，然后空了仔细看一下，收获还是挺多的。 参考：https://blog.csdn.net/bruce_6/article/details/38299199讲得很清除 package com.arraysort; /** * @author * @date 2022/1/20 */ public class ComparableTimeSortDemo { public void sort(Object[] a, int first, int len){
BigInteger用法
命z的博客
02-18 4万+
1.java中可以使用BigInteger操作大整数，也可以转换进制。如果在操作的时候一个整型数据已经超过了整数的最大类型长度long的话，则此数据就无法装入，所以，此时要使用BigInteger类进行操作。这些大数都会以字符串的形式传入。   2.BigInteger类常用方法 BigInteger abs() 返回大整数的绝对值 BigInteger add(BigInteger v...
深入理解Arrays.sort(）
热门推荐
github_38838414的博客
06-10 6万+
深入理解Java 中的Arrays.sort(）方法 Java的Arrays类中有一个sort()方法，该方法是Arrays类的静态方法，在需要对数组进行排序时，非常的好用。 但是sort()的参数有好几种，基本上是大同小异，下面是以int型数组为例的Arrays.sort(）的典型用法 import java.util.Arrays; import java.util.Comparato...
踩坑笔记 —— Arrays.sort()方法
负重前行
11-18 1375
Arrays.sort()方法是一个java自带的为数组排序的方法，排序方法为双轴快排（具体双轴快排可以自行百度一下，后续有精力的话我也会总结一篇该算法的文章），虽然一直知道这个方法但是其实很少用到，今天在刷leetcode的时候正好碰到一道题，在解题过程中我使用了带参数的sort方法 —— sort(int[] a, int fromIndex, int toIndex)，看参数名称也很好理解，...
输入一个字符串S和字符串数组arr,输出arr中以s为前缀的字符串并排序
qq_44837912的博客
03-22 784
输入描述： 第一行：输入一个字符串S 第二行：字符串数组arr 输出描述： 输出arr中以s为前缀的字符串并排序 示例 输入： ab abc bbd aba abk abd cc dd 输出： aba abc abd abk 代码 import java.util.Arrays; import java.util.Scanner; public class Main { ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值