*数组的高级排序
*冒泡排序
两个两个比较，大的往后
*选择排序
从0索引开始，用它对应的元素一次和后面遏制进行比小的往前放，第一次比较完毕，最小值出现在了最小索引处，
*1）用0索引对应的元素依次和后面的索引对应的元素进行比较
比length.arr-1次
*二分查找;二分搜索法
*前提条件：数组必须是有序的（一个排好序的数组）
*思想：猜想中间的索引，这要可以将数组减半
*步骤：
1）定义最小索引，最大索引
2）计算中间索引
3）拿中间索引的元素和要查找的索引进行比较
相等：直接返回中间索引
不相等：
大了：左边找
小了：右边找
4）重新获取最小索引，最大索引，计算中间索引
5）回到第三步
如果是一个乱序，不可以使用二分法；由于二分法会改变最初的索引找到的已经不是原来的你要查找的索引了；（使用基本查找就可以了）
*Arrays类
针对数组操作的工具类
*常用的几个方法：
*public static String toString（int[] arr ）：将任意数组义字符串形式显示出来
*toString底层会对数组对象进行非空判断
数组：当前对象为空，返回null
当前对象非空，但没有数据，返回[]；
当前数组有数据，创建字符串缓冲区，返回字符串缓冲区本身
*public static void sort(int arr[])：快速排序（给指定数组进行升序排序）
package arrays;
import java.util.Arrays;
import java.util.Scanner;
public class ArraysDemo1 {
public static void main(String[] args) {
System.out.println("请输入一个字符串：");
Scanner sc=new Scanner(System.in);
//可以使用sc.next()但是一般你接受的是什么类型就调用什么类型的输入方法
String str=sc.nextLine();
//将字符串转换成字符数组
char[] ch=str.toCharArray();
//调用Arrays类中提供的sort方法sort方法内部会调用DualPivotQuicksort.sort(a)快速排序
Arrays.sort(ch);
//输出时将数组要转换回字符串输出
System.out.println("排序后的字符串是："+Arrays.toString(ch));
System.out.println("------------------------------------");
//调用自己写的排序方法
sortArray(ch);
System.out.println("排序后的字符串是："+Arrays.toString(ch));
}
public static void sortArray(char[] ch){
char temp=0;
for(int i=0;i<ch.length;i++){
for(int j=i+1;j<=ch.length-1;j++){
if(ch[j]<ch[i]){
temp=ch[i];
ch[i]=ch[j];
ch[j]=temp;
}
}
}
}
}
*public static int binarySearch(int[]arr,int key):二分查找
*如果找不到你要找的值，那么返回-6或-1
package arrays;
import java.util.Arrays;
public class ArraysDemo2 {
public static void main(String[] args){
int []arr={43,12,56,32,89,43,23};
System.out.println("最初的数组是："+Arrays.toString(arr));
Arrays.sort(arr);
//注意：调用Arrays中的toString()方法将数组转成字符串再输出否则输出的将是一个地址
System.out.println("排序后的数组是："+Arrays.toString(arr));
//进行二分查找时由于是对一个有序数组进行查找，所以必须是一个排好序的数组，否则你要找的数的下标将不是原来的下标
//二分查找时如果找不到会返回-1，或-6；
System.out.println("查到的下标是排好序数组的下标："+Arrays.binarySearch(arr, 3));
}
}
//Arrays.binarySearch(arr, 3)
//Arrays.binarySearch(arr, 45)
//Arrays.binarySearch(arr, 43)
Java面向对象原则
实际开发中有对象存在，一定要给对象非空判断
成员变量在堆内存，局部变量在栈内存
*System类
*该类有构造方法，所以字段和成员都用静态修饰
*两个字段 ：
*Io流：设备和设备之间的数据传输（内存和硬盘上的传输）
in、out都和流有关
InputStream in=System.in;
常用方法：
*public static void gc():运行垃圾回收器
调用gc方法暗示了Java虚拟机回收未用对象，以便能够快速的重用这些对象当前占用的内存，最终调用的就是重写之后finalize（）回收不用的对象
package system;
public class Student {
//成员变量私有，禁止在外部直接调用成员变量
private String name;
private int age ;
public Student() {
super();
}
public Student(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;
}
//要以文本形式输出当前变量必须重写toString()方法，否则输出的将是一个地址值
@Override
public String toString() {
return "Student [name=" + name + ", age=" + age + "]";
}
//重写Object中的finalize()方法
@Override
protected void finalize() throws Throwable {
System.out.println("当前垃圾回收器需要回收不用对象"+this);
super.finalize();
}
package system;
public class SystemDemo {
public static void main(String[] args) {
Student st=new Student("佐助", 17) ;
System.out.println(st);
st=null ;
//当前Student没有更多的引用
//启动垃圾回收器
System.gc() ;//当前垃圾回收器需要回收不用对象
}
}
* public static void exit(int status):终止当前正在运行的java虚拟机，参数用作状态码；根据惯例，非0的状态码表示异常终止
package system;
import java.util.Scanner;
public class SystemDemo1 {
public static void main(String[] args) {
Scanner sc=new Scanner(System.in);
System.out.println("请输入一个字符串：");
String str=sc.nextLine();
System.out.println("str："+str);
//调用exit()方法
System.exit(0) ;
//退出JVM；所以exit()也可以退出循环
System.out.println("这句话不会输出！！");
}
}
*public static long currrentTimeMillis ()：返回当前系统毫秒值
单独使用没有意义，可以用于计算一个应用程序的毫秒值
package system;
public class SystemDemo2 {
public static void main(String[] args){
//获取当前系统时间毫秒值
long time=System.currentTimeMillis() ;//1510240353510
//单独使用是没有意义
System.out.println(time);
//一般用于计算某一个应用程序的耗时/毫秒
long start = System.currentTimeMillis() ;
for(int i=0;i<10000;i++){
System.out.println(i);
}
//计算上述循环所需要的时间
long end=System.currentTimeMillis() ;
System.out.println("for循环语句耗时:"+(end-start)+"毫秒");//前for循环语句共耗时:4628毫秒
}
}
* public static void arraycopy(Object src,int srcPos,Object dest int destPos,int length):
从指定源数组中复制一个数组，复制从指定的位置开始，到目标数组的指定位置结束。
package system;
import java.util.Arrays;
public class SystemDemo3 {
public static void main(String[] args) {
//定义两数组,静态初始化
int []arr={1,2,3,4,5,6} ;
int []arr1={11,12,13,14,15,16} ;
System.out.println("初始arr:"+Arrays.toString(arr));
System.out.println("初始arr:"+Arrays.toString(arr1));
System.out.println("--------------------------------");
//复制数组;需要注意的是在Java中System.arraycopy(arr,start,arr1,start,end)
//都是不包括end的知道end-1
System.arraycopy(arr,0,arr1,0,5) ;
//以字符串形式输出复制后的数组
System.out.println("arr:"+Arrays.toString(arr));
System.out.println("arr:"+Arrays.toString(arr1));
System.out.println("--------------------------------");
System.arraycopy(arr,0,arr1,0,6) ;
//输出复制后的数组
System.out.println("arr:"+Arrays.toString(arr));
System.out.println("arr:"+Arrays.toString(arr1));
}
}
*BigDecimal类
对于浮点类型来说，他们的存储和整形的存储是不一样的，是按照有效数字位来进行存储的，浮点类型在计算的时候容易损失精度计算结果不精确，Java提供了这个类
*public static BigDecimal add（BigDecimal augend）:加
*public static BigDecimal subtract（BigDecimal subtrachend）:减
*public static BigDecimal multiply（BigDecimal multiplicand）：乘
*public static Bigdecimal divide(BigDecimal divistor):除
*public BigDecimal divide(BigDecimal divisor,int scale,int roundingMode)
//参数1:商; 参数2:保留几位小数; 参数3:舍入的一种模式:ROUND_HALF_UP
package bigdecimal;
import java.math.BigDecimal;
public class BigDecimalDemo1 {
public static void main(String[] args) {
//创建BigDecimal对象
BigDecimal bd=new BigDecimal("6.28") ;
BigDecimal bd1=new BigDecimal("3.14") ;
//add(BigDecimal augend):加
System.out.println("add:"+bd.add(bd1));
//subtract(BigDecimal subtrahend):减
System.out.println("sub:"+bd.subtract(bd1));//0.68
//multiply(BigDecimal multiplicand):乘
System.out.println("multiplicand:"+bd.multiply(bd));
//divide(BigDecimal divisor):除
System.out.println("divide:"+bd.divide(bd1));
//divide(BigDecimal divisor,int scale,int roundingMode)
//参数1:商, 参数2:保留几位小数,参数3:舍入的一种模式:ROUND_HALF_UP
System.out.println("divide:"+bd1.divide(bd, 3, BigDecimal.ROUND_HALF_UP));
System.out.println("divide:"+bd1.divide(bd, 5, BigDecimal.ROUND_HALF_UP));
}
}
*BigInteger类
用来计算超出Integer数据范围的数据
* public BigInteger add(BigInteger val)
返回其值为 (this + val) 的 BigInteger。
*public BigInteger subtract(BigInteger val)
返回其值为 (this - val) 的 BigInteger。
*public BigInteger multiply(BigInteger val)
返回其值为 (this * val) 的 BigInteger。
*public BigInteger divide(BigInteger val)
返回其值为 (this / val) 的 BigInteger
* public BigInteger[] divideAndRemainder(BigInteger val)
返回包含 (this / val) 后跟 (this % val) 的两个 BigInteger 的数组。
参数：
val - 此 BigInteger 要除以的值和计算所得的余数。
package biginteger;
import java.math.BigInteger;
public class BigIntegerDemo {
public static void main(String[] args){
//创建对象
BigInteger bg=new BigInteger("215") ;
BigInteger bg1=new BigInteger("49") ;
//public BigInteger add(BigInteger val)
System.out.println("add:"+bg.add(bg1));
//public BigInteger subtract(BigInteger val)
System.out.println("subtract:"+bg.subtract(bg1));
//public BigInteger multiply(BigInteger val)
System.out.println("multiply:"+bg.multiply(bg1));
//public BigInteger divide(BigInteger val)
System.out.println("divide:"+bg.divide(bg1));
//返回的是数组第一个元素是商，第二个是余数
BigInteger[] bi=bg.divideAndRemainder(bg1) ;
System.out.println("bi[0]:"+bi[0]);
System.out.println("bi[1]:"+bi[1]);
}
}
*Calendar类
是一个抽象类，不能实例化，为特定瞬间与YEAR、MONTH、DAY_OF_MONTH、HOUR等日历字段（常亮字段）之间的转换提供一些方法
*实例化：静态方法：public static Calender getInstans();//创建日历类对象
Calendar c=Calendar.getInstance();
public int get(int field):返回所给定日历字段的值
int year=c.get(calendar.YEAR)
*字段
*public static final int YEAR:表示日历中 的年
*public static final int MONTH:月份:是0开始计算的
*public static final int DATE:和DAY_OF_MONTH是同义词,表示月份中的某天
*成员方法
*public abstract voi add(int field,int amount):为给定日历的字
添加（eg：+3）或者减去时间的偏移量（eg：-3）
*public final void set(int year,int month,int date):设置指定年月日字段
设置完要用get（）去获取
*Date类（导包：Ctrl+Shift+o）
日期类：精确到毫秒，表示特定的时间
两个构造方法：
*public Date():表示分配的一个Date对象：无参,获取当前系统的具体时间（常用）
Date d=new Date（）
输出：星期 月份 时间 ……Date日期格式
*public Date(long date)：指定一个时间毫秒值和它1970-1-1 00:00:00有时间差
package date;
import java.util.Date;
public class DateDemo {
public static void main(String[] args) {
//创建对象:无参构造
Date date=new Date();
System.out.println(date);
//设置时间
long time=1000/60/60;
//指定一个时间毫秒值和1970-1-1 00:00:00有时间差
Date date1=new Date(time);
System.out.println(date1);
}
}
*两个成员方法：
*public long getTime():获取当前时间毫秒值
如果知道Date对象，可以通过getTime（）获取时间毫秒值
通过System也可以获取当前系统的时间毫秒值
*有时候会叫Date对象------>String类型的日期的文本格式：格式化
或String类型的文本格式------->Date：解析
*public Date parse（String source）:该方法会抛出异常，ParseException(解析时期异常)
要进行转换必须使用中间桥梁DateFormat：时日期/时间格式化子类的抽象类
所以要通过SimpleDateFormat具体类实例化
SimpleDateFormat
Date对象------>String类型的日期的文本格式：格式化
Date d=new Date()
//创建SimpleDateFormat对象
SimpleDateFormat sdf=new SimpleDateFormat(shijianmoshi)
Date date=sdf.toString()
*构造方法
*public SimpleDateFormat（）;给定一个模式，是日期格式化
*public void setTime(long time):设定时间毫秒值
String类型的文本格式------->Date：解析
//一定要保证SimpleDateFormat中的StringPattern这个模式和当前所给字符串的文本格式必须一致
*创建SimpleDateFormat类的对象，用该对象解析String的日系的“文本格式”
package date;
import java.text.SimpleDateFormat;
import java.util.Scanner;
import java.util.Date;
public class DateDemo1 {
public static void main(String [] args) throws java.text.ParseException{
Scanner sc=new Scanner(System.in);
System.out.println("请输入你的出生日期（yyyy年MM月dd日）：");
String str=sc.nextLine();
SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日") ;
Date date=sdf.parse(str);
long time=date.getTime();
long nowtime=System.currentTimeMillis();
long timecount=nowtime-time;
long day=timecount/1000/60/60/24;
System.out.println("你来到这个世界已经："+day+"天了");
}
}
*math类
*针对jdk5.0以后的新特性，静态方法可以静态导入
*常用成员方法
*public static int abs(int a):绝对值
*public static double ceil(double a):向上取整
*public static double floor(double a):向下取整
*public static double max(double a,double b):获取最大值
*public static double min(double a,double b):获取最小值
*public static double pow(double a,double b):a的b次幂
*public static double random():取值范围:[0.0,1.0)
*public static long round(double a):四舍五入
*public static double sqrt(double a):一个数的正平方跟
package math;
public class MathDemo {
public static void main (String[] args){
System.out.println(Math.abs(-100));
System.out.println(java.lang.Math.abs(-100));
System.out.println(java.lang.Math.abs(-100));
//public static double ceil(double a):向上取整
System.out.println("ceil:"+Math.ceil(12.34));
System.out.println("ceil:"+Math.ceil(12.54));
//public static double floor(double a):向下取整
System.out.println("floor:"+Math.floor(12.34));
System.out.println("floor:"+Math.floor(12.56));
// 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));
//public static double sqrt(double a):一个数的正平方跟
System.out.println("sqrt:"+Math.sqrt(4));
}
}
