[2017.11.04]数组高级&arrays&类
来源：互联网 发布：php 协程 异步 编辑：程序博客网 时间：2024/05/29 02:56
数组高级
一. 冒泡排序
冒泡排序的思想:
两两比较,大的往后放,第一次比完,最大值出现在最大索引处,依次进行这样的比较
演示:
public class ArrayTest { public static void main(String[] args) { //定义一个数组,静态初始化 int[] arr = {24,69,80,57,13} ; System.out.println("排序前:"); //遍历数组 printArray(arr) ; /*//第一次比较 //arr.length-1:为了防止角标越剧 //arr.length-1-0:为了减少比较的次数 for(int x = 0 ; x < arr.length-1-0;x++){ //判断:两两比较,大的往后方法 if(arr[x]>arr[x+1]){ //中间变量进行互换 int temp = arr[x] ; arr[x] = arr[x+1] ; arr[x+1] = temp; } } System.out.println("第一次比较后:"); printArray(arr) ; //第二次比较: for(int x = 0 ; x < arr.length-1-1; x ++){ if(arr[x]>arr[x+1]){ int temp = arr[x] ; arr[x] = arr[x+1] ; arr[x+1] =temp ; } } System.out.println("第二次比较后:"); printArray(arr) ; //第三次比较: //arr.length-1:为了防止角标越界 ////arr.length-1-2:为了减少比较的次数 for(int x = 0 ; x < arr.length-1-2; x ++){ if(arr[x]>arr[x+1]){ int temp = arr[x] ; arr[x] = arr[x+1] ; arr[x+1] =temp ; } } System.out.println("第三次比较后:"); printArray(arr) ; //第三次比较: //arr.length-1:为了防止角标越界 ////arr.length-1-3:为了减少比较的次数 for(int x = 0 ; x < arr.length-1-3; x ++){ if(arr[x]>arr[x+1]){ int temp = arr[x] ; arr[x] = arr[x+1] ; arr[x+1] =temp ; } } System.out.println("第四次比较后:"); printArray(arr) ;*/ /** * 上述代码重复度高,所以改进 */ /* for(int x = 0 ; x <4 ; 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 ; } } } System.out.println("排序后:"); printArray(arr) ;*/ /** * 上述代码不够好,如果数组非常多,那么如何进行操作,应该定义一个功能,当前比较的次数是一个数组长度-1次 */ 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,....] 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]+", "); } } }}二. 选择排序
选择排序:
数组的0索引依次和后面的索引进行比较,对应的元素小的往前方法,依次比较,就可以得到一个排好序的数组
演示:
public class ArrayDemo { public static void main(String[] args) { //定义一个数组,静态初始化 int[] arr = {24,69,80,57,13} ; //排序前 System.out.println("排序前:"); printArray(arr) ; /*//第一次比较 int x = 0 ; 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 ; } } System.out.println("第一次比较后:"); printArray(arr) ; //第二次比较 x = 1 ; 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 ; } } System.out.println("第二次比较后:"); printArray(arr) ; //第三次比较 x = 2 ; 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 ; } } System.out.println("第三次比较后:"); printArray(arr) ; //第四次比较 x = 3 ; 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 ; } } System.out.println("第四次比较后:"); printArray(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 ; } } }*/ //调用 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]+", "); } } }}三. 二分搜索法
二分查找:针对数组一定有序的!
(之前查找元素第一次在数组中出现的索引,基本查找法(从头查到尾))解决思路:
1)定义最小索引和最大索引
2)计算出中间索引
3)拿中间索引对应的元素和要查找的元素进行比较
如果相等:直接返回中间索引
不相等:
大了,左边找
小了,右边找
4)重新获取最小索引和最大索引,计算出中间索引
5)回到3)继续查找
演示:
public class ArrayDemo { public static void main(String[] args) { //定义一个数组,静态初始化 int[] arr = {11,22,33,44,55,66,77} ; //需求:查找33元素对应的索引 int index = getIndex(arr, 33) ; System.out.println("index:"+index); //需求:要查找333元素对应的索引 //如果查找的这个元素在数组中查不到呢? int index2 = getIndex(arr, 333) ; System.out.println("index2:"+index2); } /** * 两个明确: * 明确返回值类型: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 ; //拿中间索引对应的元素和要查找的value元素进行比较 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这个元素在数组中的索引 * 讲数组进行排序 * 冒泡排序 * 选择排序 * 注意: * 现在得到这个索引已经发生变化了,由于排序,改变了原来是数组中元素的顺序,所以遇到这种情况,就不要使用二分查找,就是用最基本的查找方法(从头查到尾) * @author Apple */public class ArrayTest { public static void main(String[] args) { //定义一个数组 int[] arr ={24,69,80,57,13} ; //首先对数组排序 selectSort(arr) ; //排序后在查找 int index = getIndex(arr, 80) ; System.out.println("index:"+index); } //选择排序 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 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 ; } //找不到返回-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.println(arr[x]+"]"); }else{ System.out.print(arr[x]+", "); } } }}Arrays
Arrays:此类包含用来操作数组（比如排序和搜索）的各种方法(针对数组操作的工具类)
常用的几个方法:
public static String toString(int[] a):将任意类型的数组以字符串形式显示出来!
public static void sort(int[] a):快速排序:(将给定数组中元素升序排序)
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} ; //讲数组转成字符串的形式 System.out.println("toString():"+Arrays.toString(arr)); //[24, 69, 80, 57, 13] //public static void sort(int[] a):快速排序:(将给定数组中元素升序排序) Arrays.sort(arr) ; //在调用Arrays.toString(int[] a):将排好序的数组以String形式显示出来 System.out.println(Arrays.toString(arr) ); //[13, 24, 57, 69, 80] //public static int binarySearch(int[] a, int key) //查找57元素在数组中的索引 int index = Arrays.binarySearch(arr, 57) ; System.out.println("index:"+index); //需求:查找577这个元素的索引 int index2 = Arrays.binarySearch(arr, 577) ; System.out.println("index2:"+index2);//-6 }}4.Arrays常用方法的源码:
public static String toString(int[] a):int[] arr = {24,69,80,57,13} ;System.out.println(Arrays.toString(arr)) ;Arrays的toString(int[] arr)的源码Java面向对象的原则: 实际开发中有对象存在,一定要给对象做非空判断! //arr=a={24,69,80,57,13} public static String toString(int[] a) { if (a == null)//判断数组对象为空 return "null";//当前对数组对象为空 int iMax = a.length - 1;//a = arr.length-1 = 4 ; if (iMax == -1) //数组对象不为空,但是没有数据 return "[]";//返回[] //数据对象不为空,并且有数据:24, 69,80,57,13 StringBuilder b = new StringBuilder();//创建一个字符串缓冲区 b.append('[');//拼接了左中括号 for (int i = 0; ; i++) { b.append(a[i]);//字符串缓冲区对象.append(arr[i]) if (i == iMax)//i==4 return b.append(']').toString(); //13] b.append(", ");//没有取到最大索引:24, 69, 80, 57, } } //排序后的 [13, 24, 57, 69, 80] public static int binarySearch(int[] a, int key) binarySearch(int[] arr,int key)的源码 public static int binarySearch(int[] a, int key) { return binarySearch0(a, 0, a.length, key); } private static int binarySearch0(int[] a, int fromIndex, int toIndex, int key) { //int[] a = arr {13, 24, 57, 69, 80} //fromIndex = 0 从指定的索引开始搜索 //toIndex=arr.length = 5 //int key 577 int low = fromIndex; //low = 0 int min int high = toIndex - 1;// high = arr.length-1 = 4 ; int max while (low <= high) { {13, 24, 57, 69, 80} int mid = (low + high) >>> 1; int mid = (0+4)>>>1 // mid =2 ,mid=3,mid=4 int midVal = a[mid]; //int mindVal= arr[mid] = 57或者 69 或者80 if (midVal < key) //if(midValue < key = 577) low = mid + 1; //low=min = mid+1 =3 或者 4 , 或者5 else if (midVal > key) high = mid - 1; else return mid; // key found //midVal ==value return mid ;返回中间索引 } return -(low + 1); // key not found. return -(low+1)=-(5+1) = -6 //找不到这个值 }5.演示:
import java.util.Scanner;/** * 字符串中的字符进行排序。 举例："dacgebf" 结果："abcde 改进:键盘录入一个字符串 * @author Apple */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); } 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 ; } } } }}System
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 SystemDemo { public static void main(String[] args) {// Scanner sc = new Scanner(System.in) ;// System.err.println("请您输入一个数据:");// System.out.println("hello"); //创建Person类对象 Person p = new Person("高圆圆", 27) ; System.out.println(p); p = null ; //当前Person变成空了,没有更多的引用了 //启动垃圾回收器 System.gc() ;//当前垃圾回收器需要回收不用对象了Person [name=高圆圆, age=27] }}public class SystemDemo { public static void main(String[] args) { //输出语句 /*System.out.println("我们喜欢高圆圆..."); //调用exit()方法 System.exit(0) ;//JVM已经退出了,还可结束循环语句,调用该方法Jvm都退出了,所以循环也就结束了 System.out.println("我们也喜欢杨桃...");*/ //单独使用// 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循环语句共耗时:4628毫秒 }}public class Person { //成员变量 private String name; private int age ; public Person() { super(); } 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 + "]"; } //重写Object中的finalize()方法 @Override protected void finalize() throws Throwable { System.out.println("当前垃圾回收器需要回收不用对象了"+this); super.finalize(); }}5.System里面的常用的成员方法:
public static void arraycopy(Object src,int srcPos,Object dest, int destPos,int length)
指定源数组中复制一个数组，复制从指定的位置开始，到目标数组的指定位置结束
6.演示:
import java.util.Arrays;public class SystemDemo2 { public static void main(String[] args) { //定义两数组,静态初始化 int[] arr1 = {11,22,33,44,55,66} ; int[] arr2 = {3,4,5,6,7,8,9} ; //复制数组 System.arraycopy(arr1, 2, arr2, 1, 2) ; //分别将arr1 和arr2数组以字符串形式显示出来 System.out.println("arr1:"+Arrays.toString(arr1)); System.out.println("arr2:"+Arrays.toString(arr2)); /** * arr1:[11, 22, 33, 44, 55, 66] * arr2:[3, 33, 44, 6, 7, 8, 9] */ }}BigDecimal
对于浮点类型的数据类说,他们存储和整数的存储是不一致的,是按照有效数字位来进行存储的,浮点类型的数据计算的时候容易损失精度,计算出来的结果不精确,Java针对这种情况:提供了这个 BigDecimal
作用:来提供浮点类型数据的精确计算!可变的、任意精度的有符号十进制数
构造方式:
public BigDecimal(String val)演示:
public class BigDecimalDemo { 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); }}5.public BigDecimal(String val)常用的成员方法:
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
6.演示:
import java.math.BigDecimal;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
BigInteger:
用来计算超出了Integer类型范围的数据演示:
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") ;// java.lang.NumberFormatException: For input string: "2147483648" //当前该数据已经超出了Integer的取值范围// System.out.println(i); BigInteger i = new BigInteger("2147483648") ; System.out.println("i:"+i); }}3.BigInteger的构造方法
public BigInteger(String val)将字符串表示的数字封装成BigInteger类型
4.成员方法:
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数组,数组中的元素:商,余数
5.演示:
import java.math.BigInteger;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是同义词,表示月份中的某天
4.演示:
import java.util.Calendar;public class CalendarDemo { 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+"日"); }}5.Calendar常用的成员方法:
public abstract void add(int field,int amount)
为给定的日历的字段添加或者减去时间偏移量
public final void set(int year,int month,int date)
设置日历字段 YEAR、MONTH 和 DAY_OF_MONTH 的值
6.演示:
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+"日"); //需求: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+"日"); }}7.演示:
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月份中的天,输出即可 * * @author Apple */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类
Date类:日期类:
表示特定的瞬间，精确到毫秒。常用的构造方式:
public Date():表示分配的一个Date对象:无参: 通过无参构造获取当前系统的具体的时间
public Date(long date):指定一个时间毫秒值 和它1970-1-1 00:00:00有时间差演示:
import java.util.Date;public class DateDemo { public static void main(String[] args) { //创建日期对象 Date d = new Date() ; //输出日期对象 System.out.println("d:"+d);//Sat Nov 04 15:05:43 CST 2017 :获取当前系统的年月日以及时分秒 星期... //设置一个时间long long time = 1000/60/60 ; Date d2 = new Date(time) ; System.out.println("d2:"+d2); }}4.Date中的两个成员方法
public long getTime():获取当前时间毫秒值
如果知道Date对象,可以通过getTime()获取时间毫秒值
public void setTime(long time)
5.演示:
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); }}6.将Date对象—>String类型的日期的”文本格式”: 格式化
public final String format(Date date)
String类型日期的”文本格式”—->Date日期对象:解析
public Date parse(String source) 该方法本身会抛出一个异常:ParseException(解析异常:编译时期异常)
要进行转换:必须使用中间桥梁:DateFormat 是日期/时间格式化子类的抽象类，它以与语言无关的方式格式化并解析日期或时间。
日期/时间格式化子类（如 SimpleDateFormat）允许进行格式化（也就是日期Date -> 文本String）、解析（文本String-> 日期Date）和标准化
但是,DateFormat是抽象类,不能直接实例化,使用的是它更具体的子类进行实例化:SimpleDateFormat 是一个以与语言环境有关的方式来格式化和解析日期的具体类
7.常用的构造方法:
Date—格式化—>String文本格式
public SimpleDateFormat(String pattern)用给定的模式和默认语言环境的日期格式符号构造 SimpleDateFormat
8.日期和时间模式
y 年 比如:2017—->yyyy
M 年中的月份:2——>MM
d 月份中的天数 :—–>dd
H 小时 HH
m 小时中的分钟数 mm
s 分钟中的秒数 ss
9.演示:
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); }}10.DateUtil:是将Date和String相互转换的日期工具类
11.演示:
import java.text.ParseException;import java.text.SimpleDateFormat;import java.util.Date;public class DateUtil { //将无参构造私有化,为了不让外界创建对象 private DateUtil(){ } /** * 该方法是将Date日期对象格式化成一个String日期"文本格式" * @param d * 需要被转换的日期对象 * @param format * 需要转换的时候提供的一种模式 * @return * 最终返回的就是日期的文本格式 */ 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) ; }}12.日期和String相互转换的一个测试类
13.演示:
import java.text.ParseException;import java.util.Date;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); }}14.演示:
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)输出 * @author Apple */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):一个数的正平方跟
2.演示:
//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){// }}阅读全文
0 0
- [2017.11.04]数组高级&arrays&类
- 数组高级以及Arrays、Character
- Arrays类操作数组
- 数组工具类Arrays
- Arrays数组工具类
- Arrays数组工具类
- Java数组--Arrays类
- Arrays数组工具类
- 黑马程序员--StringBuffer类数组高级Arrays类包装类day(10)
- 黑马程序员——高新技术---Java基础-常用类-排序,Arrays高级数组,Integer类
- 黑马程序员—Arrays工具类，数组的高级操作，基本数据类型包装类
- 13 API-常用类(StringBuffer,数组高级以及Arrays,基本类型包装类{Integer,Character})
- 工具类 Collections Arrays asList 数组变集合 集合变数组 高级for循环 可变参数 。。。 静态导入
- 常见对象_StringBuffer、数组高级以及Arrays、Integer、Character总结
- 数组排序,Arrays数组工具类专题(Arrays工具类)
- Arrays类解析及数组
- Arrays数组类的学习
- Java 数组工具类-Arrays
- 文章标题
- 文章标题
- 基于Express React AntD和MongoDB构建一个CMS系统
- 原生php mysql 查询出数组，为什么只查询出一条数据，封装的phpmysql类
- Linux设备树解析
- [2017.11.04]数组高级&arrays&类
- 浅谈人工智能：现状、任务、构架与统一 | 正本清源（看完有新认知）
- Jzoj5451【NOIP2017提高A组冲刺11.4】Genocide(待补充)
- 二进制的一些知识
- linux常用指令[日常笔记]
- wxWidget教程（8）——字符串与转换
- 小结 | C++（二）| 默认成员函数、this指针
- OpenCL版Caffe安装教程
- Visual Studio 2015开了个小玩笑
