选择排序 Date等常用类

最新推荐文章于 2021-09-25 00:00:00 发布

weixin_38816786

最新推荐文章于 2021-09-25 00:00:00 发布

阅读量162

点赞数

本文链接：https://blog.csdn.net/weixin_38816786/article/details/78493844

版权

1. 选择排序:

数组的0索引依次和后面的索引进行比较,对应的元素小的往前,依次比较,就可以得到一个排序号的数组

public class ArrayDemo {

public static void main(String[] args) {

int []arr={12,15,2,32,315,15,21};

System.out.println("排序前");

printArray(arr);

selsectSort(arr);

System.out.println("");

printArray(arr);

}

private static void printArray(int[] arr) {

System.out.print("[");

for(int x=0;x<arr.length;x++){

if(x==arr.length-1){

System.out.print(arr[x]+"]");

}else{

System.out.print(arr[x]+",");

}

public static void selsectSort(int[]arr){

for(int x=0;x<arr.length-1;x++){

for(int y=x+1;y<arr.length;y++){

if(arr[y]<arr[x]){

int temp=arr[x];

arr[x]=arr[y];

arr[y]=temp;

}

2. 查找元素第一次在数组中出现的索引,基本查找法(从头查到尾)

二分查找条件:数组一定是要有序的

二分查找(折半查找)的思路:

1. 定义最小索引和最大索引

2. 计算出中间索引

3. 拿中间的索引对应的元素和要查找的元素进行比较

如果相等:直接返回中间索引

不相等的话:大了,左边找.

小了,右边找

4. 重新获取最小索引和最大索引,计算出中间索引

5. 回到第三部继续查找

Eg:

public class ArrayDemo1 {

public static void main(String[] args) {

int []arr={11,22,33,55,66,77,88};

//查找55对应的索引

int index=getindex(arr,55);

//查找元素在数组中找不到

int index1=getindex(arr,555);

System.out.println("index:" +index);

System.out.println("index2:"+index1);

}

private static int getindex(int[] arr, int value) {

int max=arr.length-1;

int min=0;

int mid=(max+min)/2;

while(arr[mid]!=value){

if(arr[mid]>value){

max=mid-1;

}else if(arr[mid]<value){

min=mid+1;

}

if(min>max){

return -1;

}

mid=(max+min)/2;

}

return mid;

}

数组:

假设有一个数组

Int arr[24,69,80,57,13]

查找80在这个元素在数组中的索引

将数组进行排序冒泡排序

选择排序

注意:现在这个索引已经发生变化了,由于排序,改变了原来是数组中元素的顺序,在此情况下,级不要使用二分查找,用最基本的查找方法.

public class ArrayDemo2 {

public static void main(String[] args) {

int []arr={23,56,233,65,223};

selsectSort(arr);

printArray(arr);

int index=getIndex(arr,56);

System.out.println("index:"+index);

}

//二分查找

public static void selsectSort(int[]arr){

for(int x=0;x<arr.length-1;x++){

for(int y=x+1;y<arr.length;y++){

if(arr[y]<arr[x]){

int temp=arr[x];

arr[x]=arr[y];

arr[y]=temp;

}

public static int getIndex(int[] arr,int value){

//定义最小索引和最大索引

int min = 0 ;

int max = arr.length -1 ;

int mid = (max+min)/2 ;

while(arr[mid]!= value){

if(arr[mid] > value){

max = mid -1 ;

}else if(arr[mid]<value){

min = mid +1 ;

}

if(min >max){

return -1 ;

}

mid = (max +min)/2 ;

}

return mid ;

}

public static void printArray(int[]arr){

System.out.print("[");

for(int x=0;x<arr.length;x++){

if(x==arr.length-1){

System.out.print(arr[x]+"]");

}else{

System.out.print(arr[x]+",");

}

Arrays:此类包含用来操作数组(比如排序和搜索)的各种方法(针对数组操作的工具类)

常用的方式: public static String toString(int[]a):将任意类型的数组以字符串形式显示出来!

Publicstatic void sort(int[]a):快速排序(将给定数组中元素升序排序)

Publicstatic int binarySearch(int[]a,int key): 当前int数组一定是有有序数组

使用二分搜索法来搜索指定的int型数组,以获得指定的值

import java.util.Arrays;

public class ArrayDemo4 {

public static void main(String[] args) {

int []arr={23,465,23,5,23,3,22};

//将数组转换成字符串形式

System.out.println("toString():"+Arrays.toString(arr));

//publicstatic void sort(int[]a):快速排序:将给定数组中的元素升序排序

Arrays.sort(arr);

//在调用Arrays.toString(int[]a):将排好序的数组以String形式显示出来

System.out.println(Arrays.toString(arr));

//查找23元素在数组中的索引

int index=Arrays.binarySearch(arr,23);

System.out.println("index:"+index);

int index2=Arrays.binarySearch(arr,577);

System.out.println("index2:"+index2);

}

查询找不到的值

源码返回的是:return-(low+1);

课堂练习:字符串中的字符进行排序(按照字典顺序)

import java.util.Scanner;

public class ArrayDemo6 {

public static void main(String[] args) {

Scanner sc=new Scanner(System.in);

System.out.println("请您输入一个字符串:");

String line=sc.nextLine();

//将字符串转换字符数组

char[]chs=line.toCharArray();

//给字符数组进行冒泡排序

bubbleSort(chs) ;

String result=String.valueOf(chs);

System.out.println("result:"+result);

}

private static void bubbleSort(char[] chs) {

for(int x=0;x<chs.length-1;x++){

for(int y=0;y<chs.length-1-x;y++){

if(chs[y]>chs[y+1]){

char temp=chs[y];

chs[y]=chs[y+1];

chs[y+1]=temp;

}

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

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

构造方法：public BigDecimal(String val)

Eg:

public class BigDecimalDemo1 {

public static void main(String[] args) {

System.out.println(1.0-0.32);

System.out.println(0.01+0.09);

System.out.println(1.501*100);

System.out.println(1.031/100);

}

输出结果：

0.6799999999999999

0.09999999999999999

150.1

0.01031

Public BigDecimal(String val)

常用的成员方法:

Public BigDecimal add(BigDecimal augend):加

Public BigDecimal subtract(BigDecimalsubtrahend):减

Public BigDecimal multiply(BigDecimalmultiplicand):乘法

Public BigDecimal divide(BigDecimal divisor):除

Public BigDecimal divide(BigDecimal divisor,int scale, int roundingMode)

参数1:商，参数2：保留几位小数，参数3：舍入的一种模式：ROUND_HALF_UP

import java.math.BigDecimal;

public class BigDecimalDemo2 {

public static void main(String[] args) {

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(BigDecimalsubtrahend)：

System.out.println("sub:"+bd3.subtract(bd4));

//public BigDecimal multiply(BigDecimalmultiplicand):乘法

BigDecimal bd5=new BigDecimal("1.501");

BigDecimal bd6=new BigDecimal("100.0");

System.out.println("multiply:"+bd5.multiply(bd6));

//publicBigDecimal divide(BigDecimal divisor):除

BigDecimal bd7=new BigDecimal("1.301");

BigDecimal bd8=new BigDecimal("100");

System.out.println("divide:"+bd7.divide(bd8));

//publicBigDecimal divide(BigDecimal divisor,int scale,int roundingMode)

System.out.println("div"+bd7.divide(bd8, 3,BigDecimal.ROUND_HALF_UP));

}

输出结果：

add:0.10

sub:0.68

multiply:150.1000

divide:0.01301

div0.013

BigInteger:用来计算超出了Integer类型范围的数据

最大值：2147483647

java.lang.NumberFormatException:数组越界异常

eg：

import java.math.BigInteger;

public class BigIntergerDemo {

public static void main(String[] args) {

System.out.println(Integer.MAX_VALUE);

Integer i=new Integer("214748258");

System.out.println(i);

BigInteger i1=new BigInteger("242442");

System.out.println("i1:"+i1);

}

输出结果：

2147483647

214748258

i1:242442

BigInteger的构造方法：

public BigInteger(String val)将字符串便是的数字封装成BigInteger类型

成员方法：

public BigInteger add(BigInteger val)

public BigInteger subtract(BigInteger val)

public BigInteger multiply(BigInteger val)

public BigInteger divide(BigInteger val)

public BigInteger[]divideAndRemainder(BigInteger val)

eg:

import java.math.BigInteger;

public class BigIntegerDemo2 {

public static void main(String[] args) {

BigInteger bg1=new BigInteger("100");

BigInteger bg2=new BigInteger("50");

//publicBigInteger add(BigInteger val)

System.out.println("add:"+bg1.add(bg2));

//publicBigInteger subtract(BigInteger val)

System.out.println("sub:"+bg1.subtract(bg2));

//publicBigInteger multiply(BigInteger val)

System.out.println("mul:"+bg1.multiply(bg2));

//publicBigInteger divide(BigInteger val)

System.out.println("div:"+bg1.divide(bg2));

BigInteger[]datas=bg1.divideAndRemainder(bg2);

System.out.println("datas[0]:"+datas[0]);

System.out.println("datas[1]:"+datas[1]);

}

输出结果：

add:150

sub:50

mul:5000

div:2

datas[0]:2

datas[1]:0

Calendat日历类：

Calendar类是一个抽象类，它为特定瞬间与一组诸如YEAR.MONTH.DAY_OF_MONTH.

HOUR等日历字段之间的转换提供了一些方法。

Calendar类是一个抽象类：不能实例化，所有通过一个这个方法来创建对象。

public static final int YEAR:表示日历中的年

public static final int MONTH:月份：是从0开始计算的

public static final int DATE：和DAY_OF_MONTH是同义词，表示月份中的某天

eg:

import java.util.Calendar;

public class CalendarDemo1 {

public static void main(String[] args) {

//创建日历类对象

Calendar calendar=Calendar.getInstance();//创建日历类对象，需要通过getInstance()方法创建对象

//public static final int YEAR 获取年

int year =calendar.get(Calendar.YEAR);

//public static final int MONth 获取年中的月

int month=calendar.get(Calendar.MONTH);

//public static final int DATE 获取月份中的天

int date=calendar.get(Calendar.DATE);

System.out.println(year+"年"+(month+1)+"月"+date+"日");

//由于月份是从0月开始计算的,因此输出时候要加1

}

Calendar常用的成员方法:

public abstract void add(int field,int amount)

//为给定的日历的字段添加或者减去时间偏移量

public final void set(int year,int month,int date)

//摄制日历字段YEAR.MONTH和DAY_OF_MONTH的值

Eg:

import java.util.Calendar;

public class ClassdarDemo2 {

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 abstractvoid 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,5);

c.add(Calendar.DATE,-10);

year=c.get(Calendar.YEAR);

month=c.get(Calendar.DATE);

date=c.get(Calendar.DATE);

System.out.println(year+"年"+(month+1)+"月"+date+"日");

}

输出结果：

2017年11月8日

2014年11月8日

2019年30月29日

练习:键盘录入一个年份，获取任意一年的二月有多少天

1. 创建键盘录入对象

2. 获取日李磊对象，getInstanse()

3. 设置一个日历字段，年，月，日

日历类对象set(year,2,1):这里其实表示3月1

4. 将时间往前推一天

日历类对象，add(Calendar.Date,-1);

5. 获取DATE月份中的天，输出即可

Eg：

import java.util.Scanner;

public class CalendarDemo3 {

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);

//将时间往前推算一天

c.add(Calendar.DATE,-1);

System.out.println("任意一年的二月有"+c.get(Calendar.DATE));

}

Date:日期类:表示特定的瞬间，精确到毫秒

常用的构造方法：

PublicDate():表示分配的一个Date对象：无参：通过无参构造获取当前系统的具体时间

PublicDate(long date):指定一个时间毫秒值和格林威治时间的时间差

Eg：

import java.util.Date;

public class DateDemo1 {

public static void main(String[] args) {

Date d=new Date();

System.out.println("d:"+d);// d:Wed Nov 08 20:02:56 CST 2017

long time=111111232;

Date d2=new Date(time);

System.out.println("d2:"+d2);// d2:Fri Jan 02 14:51:51 CST 1970

}

Date中的两个成员方法：

Public long getTime():获取当前时间毫秒值

如果知道Date对象，可以通过GetTime()获取时间毫秒值

Public void setTime(long time);

Eg:

import java.util.Date;

public class DateDemo3 {

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);//1510142896725

System.out.println(System.currentTimeMillis());

d.setTime(10000) ;//设置从格林威治时间经过的时间

System.out.println(d);

}

输出结果：

Wed Nov 08 20:11:48 CST 2017

1510143108920

1510143108989

Thu Jan 01 08:00:10 CST 1970

将Date对象-àString 类型的日期的”文本格式”:格式化

public final String format(Date date)

String类型日期的”文本格式”---àDate日期对象：解析

Public Date parse(String sourse)该方法本身抛出一个异常：ParseException(解析异常:编译时期异常)文本格式解析异常

要进行转换：必须使用中间桥梁：DateFormat 是日期/时间格式化子类的抽象类

常用的构造方法：Date-à格式化-à文本格式

public SimpleDateFormat(String pattern)

用给定的模式和默认语言环境的日期格式符号构造 SimpleDateFormat

日期和时间模式： y----年 2017-àyyyy M-----月 2---àMM

d----月份中的天数 dd H----小时 HH m-----小时中的分钟 mm

s-----分钟中的秒数 ss D-----年中的天数

eg：

import java.text.ParseException;

import java.text.SimpleDateFormat;

import java.util.Date;

public class DateFormatDemo1 {

public static void main(String[] args) throws ParseException {

//Date日期对象--->格式化---->String:日期文本格式

Date d=new Date();

//创建SimpleDateFormat对象，用该对象格式化Date对象

SimpleDateFormat sd=new SimpleDateFormat("yyyy-MM-dd");

//格式化 public finalString format(Date date)

String dateste=sd.format(d);

System.out.println("dateste"+dateste);

//String日期"文本格式"----->解析----->Date对象

String s="2017-13-24";

SimpleDateFormat sd2=new SimpleDateFormat("yyyy-MM-dd");

Date d2=sd2.parse(s);

System.out.println("d2:"+d2);

}

输出结果：

dateste2017-11-08

d2:Wed Jan 24 00:00:00 CST 2018

测验中发现一个问题:当月份和天数超出12和该月的天数时，多出的天数和月份会自动往满足条件的天数往后推迟。

sd2.parse(s);会报错:需要添加throws ParseException

Math类提供了一些数学运行的方法:

常用的成员方法:
public static int abs(int a):绝对值

public static double ceil(double a):向上取整

public static double floor(double a):向下取整

public static double max(double a ,doubleb):获取最大值

public static double min(double a, doubleb):获取最小值

public static double pow(double a, doubleb):a的b次幂

public static double random():生成一个随机数取值[0.0 ,1.0]

public static long round(double a):四舍五入

public static double sqrt(double a):一个数的正平方跟

eg:

public class MathDemo {

public static void main(String[] args) {

System.out.println(Math.abs(-100));

// publicstatic double ceil(double a):向上取整

System.out.println("ceil:"+Math.ceil(12.34));

//publicstatic double floor(double a):向下取整

System.out.println("floor:"+Math.floor(12.34));

// public static double max(double a,double b):获取最大值

System.out.println("max:"+Math.max(Math.max(10,20),30));

//publicstatic double pow(double a,double b):a的b次幂

System.out.println("pow:"+Math.pow(3,5));

//publicstatic long round(double a):四舍五入

System.out.println("round:"+Math.round(12.56));

//publicstatic double sqrt(double a):一个数的正平方跟

System.out.println("sqrt:"+Math.sqrt(16));

}

System:该类没有构造方法，所以字段和成员方法都用静态方法

System.err.println: 输出的字颜色是红色的

常用的两个字段:

in,out都和流有关系:io流

public static void gc()运行垃圾回收器。Finalize：回收没有引用的对象PrintStream(字节打印流) PrintWriter(字符打印流)

System:常用的成员方法

public static void exit(int status):终止当前的虚拟机

long time = System.currentTimeMillis() ;//获取当前系统时间毫秒值

一般用来一个应用程序的耗时的毫秒数：

Eg:计算程序需要的毫秒数

public class SystemDemo2 {

private static long start;

public static void main(String[] args) {

System.out.println("我们喜欢Java");

System.out.println("我们喜欢JavaSE");

long time = System.currentTimeMillis();

System.out.println(time);

for(int x=0;x<100000;x++){

System.out.println("hello"+x);

}

long end =System.currentTimeMillis();

System.out.println("当前for循环语句共耗时:"+(end-start)+"毫秒");

}

输出结果：

当前for循环语句共耗时:1510149935573毫秒

System里面的常用的成员方法:

Public static void arraycopy (Object src,int srcPos,Object dest, intdestPos,int length)

指定源数组中复制一个数组，复制从指定的位置开始，到目标数组的指定位置结束

Eg:

import java.util.Arrays;

public class SystemDemo3 {

public static void main(String[] args) {

int []arr={11,22,33,45,45,61};

int []arr1={3,4,5,6,7,8};

System.arraycopy(arr,2,arr1,1,3);

System.out.println("arr:"+Arrays.toString(arr));

System.out.println("arr1:"+Arrays.toString(arr1));

}

吧前面的拼接到后面的

输出结果：

arr1:[11, 22, 33, 45, 45, 61]

arr2:[3, 33, 45, 45, 7, 8]

weixin_38816786

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
选择排序 Date等常用类

1. 选择排序: 数组的0索引依次和后面的索引进行比较,对应的元素小的往前,依次比较,就可以得到一个排序号的数组public class ArrayDemo {public static void main(String[] args) { int []arr={12,15,2,32,315,15,21}; System.out.println(...
复制链接

扫一扫