Java笔记第十二课（数组排序及查找）

悠悠 2022-06-06 09:08 154阅读 0赞

#### **数组排序及查找** ####

**一.数组排序**

1.选择排序法

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

例：

public class ArrayDemo {
    	
    	public static void main(String[] args) {
    		
    		//定义一个数组,静态初始化
    		int[] arr = {24,69,80,57,13} ;
    		
    		//排序前
    		System.out.println("排序前:");
    		printArray(arr) ;//调用数组遍历方法
    		
    		//调用
    		selectSort(arr) ;
    		System.out.println("排序后:");
    		printArray(arr) ;//调用数组遍历方法
    
    	}
    	
    	//将选择排序的代码封装成一个独立的功能
    	public static void selectSort(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 void printArray(int[] arr){
    		System.out.print("[");
    		//遍历数组
    		for(int x = 0 ; x < arr.length ; x ++){
    			//判断是否最大索引
    			if(x==arr.length-1){
    				System.out.println(arr[x]+"]");
    			}else{
    				System.out.print(arr[x]+", ");
    			}
    		}
    	}

冒泡排序  
思想：

两两比较,大的往后放,第一次比完,最大值出现在最大索引处,依次进行这样的比较....

例：

public class ArrayTest {
    	
    	public static void main(String[] args) {
    		
    		//定义一个数组,静态初始化
    		int[] arr = {24,69,80,57,13} ;
    		
    		System.out.println("排序前:");
    		//调用遍历数组
    		printArray(arr) ;
    		
    		bubbleSort(arr) ;
    		System.out.println("排序后:");
    		printArray(arr) ;//调用遍历数组
    
    	}
    	
    	public static void bubbleSort(int[] arr){
    		for(int x = 0 ; x < arr.length-1; x ++){
    			for(int y = 0 ; y < arr.length-1-x ; y++){
    				//判断
    				if(arr[y]>arr[y+1]){
    					int temp = arr[y] ;
    					arr[y] = arr[y+1] ;
    					arr[y+1] = temp ;
    				}
    			}
    		}
    	}

## 二.数组查找 ##

**二分法查找** （ 数组一定是排好序的 ）

思路：1)定义最小索引和最大索引  
  2)计算出中间索引  
  3)拿中间索引对应的元素和要查找的元素进行比较  
 如果相等:直接返回中间索引  
 不相等:  
  大了,左边找   max = mid -1 ;重新获取最大索引  
  小了,右边找   min = mid +1 ;重新获取最小索引  
                 计算出中间索引   mid = (max+min)/2 ;  
 4)回到3)继续查找

5)如果找不到了应该返回-1

public class ArrayDemo1 {
    	public static void main(String[] args) {
    		//定义一个有序数组
    		int [] arr = {13,21,65,71,96};
    		int index = getIndex(arr, 65);
    		System.out.println("index:"+index); //index:2
    	}
    	public static int getIndex(int [] arr,int value) {
    		// 定义最小索引和最大索引
    		int min = 0;
    		int max = arr.length - 1;
    
    		int mid = (min + max) / 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 = (min + max) / 2;
    		}
    		return mid;
    	}
    }

**注意：当需要寻找一个无序数组中某个元素第一次出现的索引时，不能排序后再用二分法查找，因为这时索引已经发生变化了,由于排序,改变了原来是数组中元素的顺序，这时要使用基本查找！**

** Arrays类：**

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

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

import java.util.Arrays;
    
    public class ArraysDemo {
    	public static void main(String[] args) {
    		//定义一个数组
    		int [] arr = {15,47,35,66,83};
    		//public static String toString(int[] a):将任意类型的数组以字符串形式显示出来!
    		System.out.println("toString():"+Arrays.toString(arr));
    		//toString():[15, 47, 35, 66, 83]
    		//public static void sort(int[] a):快速排序:(将给定数组中元素升序排序)
    		Arrays.sort(arr);
    		System.out.println("sort():" + Arrays.toString(arr));// sort():[15, 35, 47, 66, 83]
    		// public static int binarySearch(int[] a, int key)
    		// 查找66元素在数组中的索引
    		int index = Arrays.binarySearch(arr, 66);
    		System.out.println("index:"+index);//index:3
    	}
    }

练习：

import java.util.Scanner;
    
    /**
     * 对键盘录入一个字符串中的字符进行排序。
     *		举例："dacgebf"
     * 		结果："abcde
     * 		
     * */
    public class ArrayTest {
    	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);
    		//运行结果
    		/*请您输入一个字符串：
    		asdkokjfd
    		result：addfjkkos*/
    	}
    	//冒泡排序
    	public 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 ;
    				}
    			}
    		}
    	}
    
    }

## 三.常用类 ##

**BigDecimal类**

对于浮点类型的数据类说,他们存储和整数的存储是不一致的,是按照有效数字位来进行存储的,浮点类型的数据计算的时候容易损失精度,计算出来的结果不精确,

Java针对这种情况:提供了这个类  
BigDecimal:  
  作用:

来提供浮点类型数据的精确计算!可变的、任意精度的有符号十进制数  
  构造方式:  
  public BigDecimal(String val)

public class BigDecimalDemo {
    	
    	public static void main(String[] args) {
    		
    		System.out.println(1.0-0.66);
    		System.out.println(0.01+0.09);
    		System.out.println(1.4201*100);
    		System.out.println(3.141/100);
    	}
    }

常用的成员方法;  
   public BigDecimal add(BigDecimal augend):加  
   public BigDecimal subtract(BigDecimal subtrahend):减  
  public BigDecimal multiply(BigDecimal multiplicand):乘法  
  public BigDecimal divide(BigDecimal divisor):除  
   public BigDecimal divide(BigDecimal divisor,int scale,int roundingMode)  
   参数1:商,  参数2:保留几位小数,参数3:舍入的一种模式:ROUND\_HALF\_UP

public class BigDecimalDemo2 {
    	
    	public static void main(String[] args) {
    		//创建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**:

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

构造方法  
  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)  
 返回一个BigInteger数组,数组中的元素:商,余数

public class BigIntegerDemo {
    	
    	public static void main(String[] args) {
    		
    		//查看Integer类的最大值
    		System.out.println(Integer.MAX_VALUE);//2147483647
    		
    		//创建Integer对象
                    //Integer i = new Integer("2147483648") ;// java.lang.NumberFormatException: For input string: "2147483648"
    		//当前该数据已经超出了Integer的取值范围
    		//System.out.println(i);
    		
    		BigInteger i = new BigInteger("2147483648") ;
    		System.out.println("i:"+i);
    	}
    }

public class BigIntegerDemo2 {
    	
    	public static void main(String[] args) {
    		
    		//创建BigInteger对象
    		BigInteger bg1 = new BigInteger("100") ;
    		BigInteger bg2 = new BigInteger("50") ;
    		
    		//public BigInteger add(BigInteger val)
    		System.out.println("add:"+bg1.add(bg2));
    		//public BigInteger subtract(BigInteger val)
    		System.out.println("sub:"+bg1.subtract(bg2));
    		//public BigInteger multiply(BigInteger val)
    		System.out.println("mul:"+bg1.multiply(bg2));
    		//public BigInteger divide(BigInteger val)
    		System.out.println("div:"+bg1.divide(bg2));
    		
    		BigInteger[] datas = bg1.divideAndRemainder(bg2) ;
    		System.out.println("datas[0]:"+datas[0]);//2
    		System.out.println("datas[1]:"+datas[1]);//0
    		
    	}
    }

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

package org.westos_12_常用类;
    
    import java.util.Calendar;
    
    /**
     * 
     * Calendar:日历类:
     * 		Calendar 类是一个抽象类，它为特定瞬间与一组诸如 YEAR、MONTH、DAY_OF_MONTH、HOUR 等 日历字段之间的转换提供了一些方法，
     * 					并为操作日历字段（例如获得下星期的日期）提供了一些方法
     * 		Calendar该类是一个抽象类:不能实例化的,所以通过一下这个方法来创建对象
     * 					public static Calendar getInstance()
     * 					public int get(int field)返回给定日历字段的值
     * 		
     * 		public static final int YEAR:表示日历中 的年
     * 		public static final int MONTH:月份:   *是0开始计算的
     * 		public static final int DATE:和DAY_OF_MONTH是同义词,表示月份中的某天
     * */
    public class CalendarDemo1 {
    	public static void main(String[] args) {
    		//public static Calendar getInstance()创建对象
    		Calendar calendar = Calendar.getInstance();
    		
    		// public static final int YEAR  获取年
    		int year = calendar.get(Calendar.YEAR);
    		System.out.println(year);
    		
    		int month = calendar.get(Calendar.MONTH);//获取年份中的月
    		
    		int date = calendar.get(Calendar.DATE);// 获取月份中的天
    		System.out.println(year+"年"+(month+1)+"月"+date+"日");//2017年11月9日
    	}
    }

Calendar常用的成员方法:

public abstract void add(int field,int amount)  
 为给定的日历的字段添加或者减去时间偏移量  
  public final void set(int year,int month,int date)  
  设置日历字段 YEAR、MONTH 和 DAY\_OF\_MONTH 的值

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+"日");
    		
    		//需求:5年后的十天前
    		c.add(Calendar.YEAR, 5) ;
    		c.add(Calendar.DATE, -10) ;
    		
    		//获取年
    		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,20) ;
    		//获取年
    		year = c.get(Calendar.YEAR) ;
    		//获取月
    		month = c.get(Calendar.MONTH) ;
    		//月汇总的天
    		date = c.get(Calendar.DATE) ;
    		System.out.println(year+"年"+(month+1)+"月"+date+"日");
    		
    		
    	}
    }

练习：

键盘录入一个年份,获取任意一年的二月有多少天

package org.westos.calendar;
    
    import java.util.Calendar;
    import java.util.Scanner;
    
    /**
     * 键盘录入一个年份,获取任意一年的二月有多少天
     * 分析:
     * 		1)创建键盘录入对象,录入某一个年份
     * 		2)获取日历类对象,getInstance()
     * 		3)设置一个日历字段,年,月,日
     * 			日历类对象.set(year,2,1):这里其实表示3月1
     * 		4)将时间往前推一天
     * 			日历类对象.add(Calendar.DATE,-1) ;
     * 		5)获取DATE月份中的天,输出即可
     * 		
     * 
     */
    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("任意一年的二月有:"+c.get(Calendar.DATE));
    	}
    }

**  Date类:日期类:**  
  表示特定的瞬间，精确到毫秒。  
    
  常用的构造方式:  
  public Date():表示分配的一个Date对象:无参: 通过无参构造获取当前系统的具体的时间  
   public Date(long date):指定一个时间毫秒值  和它1970-1-1 00:00:00有时间差

public class DateDemo1 {
    	public static void main(String[] args) {
    		
    		Date d = new Date();
    		System.out.println("当前系统的时间为：" + d);// 当前系统的时间为：Thu Nov 09 09:32:51 CST 2017
    		// 设置一个时间
    		long time = 1000 / 60 / 60;
    		Date d2 = new Date(time);
    		System.out.println(d2);// 格林威治时间 Thu Jan 01 08:00:00 CST 1970
    	}
    }

Date中的两个成员方法  
   public long getTime():获取当前时间毫秒值  
    
  如果知道Date对象,可以通过getTime()获取时间毫秒值  
  public void setTime(long time)

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

**DateFormat：**（抽象类）

将Date对象--->String类型的日期的"文本格式":格式化  
  public final String format(Date date)  
  String类型日期的"文本格式"---->Date日期对象:解析  
  public Date parse(String source) 该方法本身会抛出一个异常:ParseException(解析异常:编译时期异常)  
    
  要进行转换:必须使用中间桥梁:DateFormat 是日期/时间格式化子类的抽象类，它以与语言无关的方式格式化并解析日期或时间。  
  日期/时间格式化子类（如 SimpleDateFormat）允许进行格式化（也就是日期Date -> 文本String）、解析（文本String-> 日期Date）和标准化  
   
  但是,DateFormat是抽象类,不能直接实例化,使用的是它更具体的子类进行实例化:  
  SimpleDateFormat 是一个以与语言环境有关的方式来格式化和解析日期的具体类  
    
  常用的构造方法:  
  Date---格式化--->String文本格式  
    
  public SimpleDateFormat(String pattern)用给定的模式和默认语言环境的日期格式符号构造 SimpleDateFormat

日期和时间模式
      			y			年	比如:2017---->yyyy
      			M			年中的月份:2------>MM
      			d  			月份中的天数 :----->dd
      			H			小时				HH
      			m			小时中的分钟数	mm
      			s			分钟中的秒数		ss

import java.text.ParseException;
    import java.text.SimpleDateFormat;
    import java.util.Date;
      
    public class DateFormatDemo {
    	
    	public static void main(String[] args) throws ParseException {
    		
    		//Date日期对象--->格式化---->String:日期文本格式
    		//创建日期对象
    		Date d = new Date() ;
    		//System.out.println(d);
    		
    		//创建SimpleDateFormat类对象,用该对象格式化Date对象
    		SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss") ;
    		//格式化
    		//public final String format(Date date)
    		String dateStr = sdf.format(d) ;
    		System.out.println("dateStr:"+dateStr);
    		
    		System.out.println("-----------------------");
    		
    		//String日期"文本格式"----->解析----->Date对象
    		/**
    		 * 注意事项:
    		 * 		一定要保证SimpleDateFormat中的String Pattern这个模式和当前给的字符串的文本格式的模式必须一致!
    		 */
    		String s = "2017-12-30" ;
    		
    		//创建SimpleDateFormat类的对象,用该对象解析String的日期的"文本格式"
    		//SimpleDateFormat sdf2 = new SimpleDateFormat("yyyy年MM月dd日") ;
    		SimpleDateFormat sdf2 = new SimpleDateFormat("yyyy-MM-dd") ;
    		//ava.text.ParseException: Unparseable date: "2017-12-30"
    		//开始解析
    		//public Date parse(String source)
    		
    		Date d2 = sdf2.parse(s);
    
    		System.out.println("d2:"+d2);
    	}
    }

DateUtil

这是将Date和String相互转换的日期工具类

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 ;*/
    		
    		return new SimpleDateFormat(format).format(d) ;
    	}
    	/**
    	 * 该方法是将String的日期"文本格式"解析成一个Date日期对象
    	 * @param s
    	 * 		表示需要被解析的日期文本格式
    	 * @param format
    	 * 		表示解析日期文本格式是需要使用的一种模式
    	 * @return
    	 * 		返回的就是日期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 ;*/
    		
    		return new SimpleDateFormat(format).parse(s) ;
    	}
    }

import java.text.ParseException;
    import java.util.Date;
    
    /**
     * 日期和String相互转换的一个测试类
     * @author Apple
     */
    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 str3 = DateUtil.dateToString(d, "HH:mm:ss") ;
    		System.out.println("str3:"+str3);
    		
    		//String---->Date
    		//模式要和字符串文本格式一致
    		String s = "2018-6-25 16:26:21" ;
    		//调用功能
    		Date date = DateUtil.stringToDate(s, "yyyy-MM-dd HH:mm:ss");
    		System.out.println("date"+date);
    		
    		
    		
    	}
    }

练习：

键盘录入你的出生年月日,计算你来到这个世界有多少天了?

import java.text.ParseException;
    import java.util.Date;
    import java.util.Scanner;
    
    /**
     * 分析:
     * 		1)键盘键盘录入出生年月日,录入这一个String类型的数据
     * 		2)创建SimpleDateFormat对象指定一种模式
     * 		3)将当前String日期文本格式转换成date对象
     * 		4)通过Date对象获取getTime():获取时间毫秒值
     * 		5)得到当前系统时间的毫秒值(System.currentTimeMillis)
     * 		6):5)-4)=long 类型的时间
     * 		7)换算成多少天
     * 		8)输出
     */
    public class MyYearOldTest {
    	
    	public static void main(String[] args) throws ParseException {
    		
    		//创建键盘录入对象
    		Scanner sc = new Scanner(System.in) ;
    		
    		//录入并接收数据
    		System.out.println("请输入你的出生年月日: ");
    		String line = sc.nextLine() ;
    		
    		//使用刚才DateUtil工具类
    		Date d = DateUtil.stringToDate(line, "yyyy-MM-dd") ;
    		//获取当前出生年日所在的时间毫秒值
    		long oldTime = d.getTime() ;
    		//获取当前系统时间的毫秒值
    		long nowTime = System.currentTimeMillis() ;
    		
    		long time = nowTime - oldTime ;
    		
    		//换算
    		long day = time/1000/60/60/24 ;
    		
    		//输出
    		System.out.println("你来到这个世界有"+day+"天了");
    	}
    }

**Math类**  
 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,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):一个数的正平方根

//import java.util.Scanner;
    //JDK5.0以后的新特性;
    //import static java.lang.Math.abs; //静态导入()import static(该方法一定是静态方法)
    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));
    		
    	}
    	
    //	public static void abs(String name){
    		
    //	}
    }

**System类:**该类没有构造方法,所以字段和成员方法都用静态修饰  
   
   常用的两个字段:  
   in ,out都和流有关系:java.io...  
    
   PrintStream(字节打印流) ps = System.out ; 标准输出流  
   PrintWriter(字符打印流)  
    
   InputStream  in =  System.in; 标准输入流   
   
  常用的成员方法:  
   public static void gc()运行垃圾回收器。   
调用 gc 方法暗示着 Java 虚拟机做了一些努力来回收未用对象，以便能够快速地重用这些对象当前占用的内存,最终调用的就是重写之后finalize()回收不用  
  的对象!  
     public static void exit(int status)终止当前正在运行的 Java 虚拟机。参数用作状态码；根据惯例，非 0 的状态码表示异常终止。  
   public static long currentTimeMillis():返回当前的时间毫秒值

import java.util.Scanner;
    
    public class SystemDemo1 {
    	public static void main(String[] args) {
    		//创建键盘录入
    		//Scanner sc = new Scanner(System.in);
    		
    		//System.out.println("请您输入一个数据：");
    		//System.out.println("Hello");PrintStream(字节打印流) ps = System.out ;标准输出流 所以可以将内容打印到控制台
    		/*Student s = new Student("dreamer_96",20);
    		System.out.println(s);//没有重写toString()时打印地址值
    		s = null;
    		System.out.println(s);//当前Student变成空了,没有更多的引用了
    		//启动垃圾回收器
    		System.gc();*/
    		
           /* System.out.println("为什么小孩子不能喝酒....");
    		
    		//调用exit()方法
    		System.exit(0) ;//JVM已经退出了,还可结束循环语句,调用该方法Jvm都退出了,所以循环也就结束了
    		
    		System.out.println("因为小孩子不喝酒也很开心啊....");*/
    		//public static long currentTimeMillis():返回当前的时间毫秒值
    		long time = System.currentTimeMillis();
    		System.out.println(time);//1510189151654
    		
    		//单独使用没意义
    		//计算某一个应用程序的耗时的毫秒数
    		long start = System.currentTimeMillis();
    		for(int x =0;x<1000;x++) {
    			System.out.println(x);
    		}
    		long end = System.currentTimeMillis();
    		System.out.println("当前for循环语句共耗时:"+(end-start)+"毫秒");//当前for循环语句共耗时:24毫秒
    	}
    }

System里面的常用的成员方法:  
  public static void arraycopy(Object src,int srcPos,Object dest, int destPos,int length)  
   指定源数组中复制一个数组，复制从指定的位置开始，到目标数组的指定位置结束

import java.util.Arrays;
    
    public class SystemDemo2 {
    	
    	public static void main(String[] args) {
    		//定义两数组
    		int[] arr1 = {11,22,33,44,55} ;
    		int[] arr2 = {3,4,5,6,7,8} ;
    		
    		//复制数组
    		System.arraycopy(arr1, 2, arr2, 1, 2) ;
    		
    		//分别将arr1 和arr2数组以字符串形式显示出来
    		System.out.println("arr1:"+Arrays.toString(arr1));  // arr1:[11, 22, 33, 44, 55]
    
    		System.out.println("arr2:"+Arrays.toString(arr2)); //arr2:[3, 33, 44, 6, 7, 8]
    		 
    	}
    }