[2017.11.04]数组高级&arrays&类

最新推荐文章于 2022-01-29 19:20:38 发布
最新推荐文章于 2022-01-29 19:20:38 发布
阅读量288 收藏
点赞数
文章标签： 冒泡排序 索引 string
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Lily_Evans/article/details/78446328
版权

数组高级

一. 冒泡排序

  1. 冒泡排序的思想:
    两两比较,大的往后放,第一次比完,最大值出现在最大索引处,依次进行这样的比较
    冒泡排序的规律

  2. 演示:

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]+", ");
            }
        }
    }
}

二. 选择排序

  1. 选择排序:
    数组的0索引依次和后面的索引进行比较,对应的元素小的往前方法,依次比较,就可以得到一个排好序的数组
    选择排序图解

  2. 演示:

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. 解决思路:
    1)定义最小索引和最大索引
    2)计算出中间索引
    3)拿中间索引对应的元素和要查找的元素进行比较
    如果相等:直接返回中间索引
    不相等:
    大了,左边找
    小了,右边找
    4)重新获取最小索引和最大索引,计算出中间索引
    5)回到3)继续查找
    二分查找图解

  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

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

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

  3. 演示:

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

  1. System:该类没有构造方法,所以字段和成员方法都用静态修饰

  2. 常用的两个字段:
    in ,out都和流有关系:java.io…
    PrintStream(字节打印流) ps = System.out ; 标准输出流
    PrintWriter(字符打印流)
    InputStream in = System.in; 标准输入流

  3. 常用的成员方法:
    public static void gc()运行垃圾回收器。
    调用 gc 方法暗示着 Java 虚拟机做了一些努力来回收未用对象，以便能够快速地重用这些对象当前占用的内存,最终调用的就是重写之后finalize()回收不用的对象!
    public static void exit(int status)终止当前正在运行的 Java 虚拟机。参数用作状态码；根据惯例，非 0 的状态码表示异常终止。
    public static long currentTimeMillis():返回当前的时间毫秒值

  4. 演示:

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

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

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

  3. 构造方式:
    public BigDecimal(String val)

  4. 演示:

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

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

  2. 演示:

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

    }
}

日历类

  1. Calendar:日历类:
    Calendar 类是一个抽象类，它为特定瞬间与一组诸如 YEAR、MONTH、DAY_OF_MONTH、HOUR 等 日历字段之间的转换提供了一些方法，并为操作日历字段（例如获得下星期的日期）提供了一些方法

  2. Calendar该类是一个抽象类:不能实例化的,所以通过一下这个方法来创建对象

  3. 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类

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

  2. 常用的构造方式:
    public Date():表示分配的一个Date对象:无参: 通过无参构造获取当前系统的具体的时间
    public Date(long date):指定一个时间毫秒值 和它1970-1-1 00:00:00有时间差

  3. 演示:

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类

  1. 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
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Algorithm：【算法进阶之路】之算法面试刷题集合—数据结构知识和算法刷题及其平台、问题为导向的十大类刷题算法(数组和字符串、链表、栈和队列、二叉树、堆、图、哈希表、排序和搜索、回溯算法、枚举/递
近期请国内外头部出版社可尽快私信博主！——心比天高，仗剑走天涯，保持热爱，奔赴向梦想！低调，谦虚，自律，反思，成长，还算是比较正能量的博主，公益免费传播……内心特别想在AI界做出一些可以推进历史进程影响力的东西(兴趣使然，有点小情怀，也有点使命感呀)…
04-22 1214
​ Algorithm：【算法进阶之路】之算法面试刷题集合—数据结构知识和算法刷题及其平台、问题为导向的十大类刷题算法(数组和字符串、链表、栈和队列、二叉树、堆、图、哈希表、排序和搜索、回溯算法、枚举/递归/分治/动态规划/贪心算法)总结 目录 相关文章 数据结构的最强学习路线之问题为导向的十大类刷题算法总结 一、学习相关的讲解与刷题平台 二、刷题集合 三、常见的十大类考试题型 相关文章 DSt：数据结构的简介、最强学习路线(逻辑结构【数组
java初学
果果
03-19 422
常用的DOS命令 dir:列出当前目录下的文件以及文件夹 md:创建目录 rd:删除目录 cd:进入指定目录 cd…:退回到上一级目录 cd:退回到根目录 del:删除文件 exit:退出dos命令行 echo javase>1.doc创建一个文件 java基础知识 java特性 简单性、面向对象、可移植性、高能性、分布性、动态性（体现在反射机制）、多线程、安全性、健壮性。 cmd里运行java文件 javac 文件名.java java
入门算法总结
m0_53328239的博客
01-29 1005
洛谷入门一到六方法总结
Java基础练习（十二）集合与数组工具类使用，BigDecimal使用，实现二分查找，快速排序
My的博客
08-20 544
1、使用Collections中的方法，完成List集合的排序，然后反转。 public class Test { public static void main(String[] args) { List list= Arrays.asList(1,2,5,9,0,6,8,44,1); Collections.sort(list); Collections.reverse(list); System.out.println(list)
java bigdecima_Java收藏排序BigDecimal
weixin_39641257的博客
03-02 2263
我想通过BigDecimal排序一个ArrayList和对砖墙来临。我有一个类，看起来有点像这样：Java收藏排序BigDecimalpublic class deal implements Comparable{protected BigDecimal bdPrice;protected int iQuantity;protected String sDealType;protected UUI...
java数组排序.docx
09-26
java语言对数组分别进行快速排序，选择排序，冒泡排序，插入排序。
[2017.11.05]正则表达式&集合&list
Lily_Evans的博客
11-05 3346
正则表达式1.演示:import java.util.Scanner;/** * 需求:校验一个QQ号码 * 定义一个规则:1)由5到10为组成的数字 * 2)不能以0开头 * 分析: * 1)键盘录入一个QQ号码,使用字符串接收 * 2)定义一个校验QQ的功能 * 3)在main()中调用返回boolean类
Unity3d 周分享（20期 2019.6.30 ）
热门推荐
游戏路上的小学生
06-30 1万+
选自过去1~2周 自己所看到外文内容：https://twitter.com/unity3d 和各种其他博客来源吧 1、Unity的Android音频延迟在2019.1.0 中改进 https://gametorrahod.com/unitys-android-audio-latency-improvement-in-2019-1-0/ 文章作者因为这个延迟问题，弄了一个，正是基于Op...
python ndimage.gaussian_4. Python--Scipy库（上/7-12）
weixin_34060773的博客
02-02 328
本文非常全面的介绍了Scipy库，希望大家有耐心的看下去。参考链接在最后。目录：1. Scipy简介1.1 子包1.2 数据结构2. Scipy开发环境安装2.1 Windows2.2 Linux3. Scipy基本功能3.1 内在Numpy数组创建3.2 矩阵4. Scipy簇聚4.1 Scipy中实现K-Means4.2 三个集群计算K均值5. Scipy常量5.1 Scipy常量包5.2 可...
数组分割 java_分割java数组
weixin_28973627的博客
02-12 2787
Java 数组1. 数组： 形同类型数据的集合叫做数组2 定义数组的方式2.1 int[] a = new int[10];2.2 int a[] = new int[10]2.3 type[] 变量名 ={new type[]}{逗号分割的初始化列表}；红色可以省略type[] 变量名 = ...文章zting科技2017-11-10515浏览量鲁卡斯队列求黄金分割数这是2012年Java...
数组和排序算法的应用 + 面试题
快乐的工程师的博客
02-07 758
数组和排序算法的应用 + 面试题 数组的定义与使用 数组是 Java 编程中最重要的数据结构之一，也是最基本的数据结构，Java 中的常用集合 ArrayList、HashMap 等内部的实现都使用到了数组结构。数组是只能用来存储一种类型的集合，可以通过下标访问数值中的所有元素。 数组的声明方式有以下两种，如整数型数组，请参考下面代码： 方式一：int[] arr; 方式二：int arr[];...
JAVA开发中数组用法_浅谈Java集合中Array(数组)的应用
weixin_39614276的博客
02-28 204
我们都知道，由于Array(数组)通常意义上讲只是一个单纯的线性序列，又基于Native，凭此它的效率历来便号称Java中最高。所以通常我们也都承认Java中效率最高的存储方式就是使用数组。但是，由于数组初始化后大小固定，索引不能超出下标，缺少灵活的扩展功能等原因，使得很多人放弃了数组的使用， 转而使用Collection,List,Map,Set等接口处理集合操作。诚然在Java中使用集合类可以...
BigDecimal的最大值，最小值，中位数，排序操作
weixin_43588364的博客
05-01 1万+
BigDecimal的最大值，最小值，中位数，排序操作 由于使用double数组对数据进行操作会引起精度损失，所以使用BigDecimal 进行计算 package com.test.annotation.test.test; import java.math.BigDecimal; import java.util.ArrayList; import java.util.Collection...
黑马程序员匠心之作|C++教程从0到1入门编程--数组 函数 指针练习
weixin_43195445的博客
10-19 295
代码功能封装一个函数，利用冒泡排序，实现对整型数组的升序排序 #include using namespace std; //冒泡排序函数 //参数一数组首地址，参数二数组长度 void bubblesort(int * arr, int len) { for (int i = 0; i < len - 1; i++) { for (int j = 0; j < len -i- 1; j++) { //如果j>j+1的值，交换数值 if (arr[j] > arr[j + 1]) {
sort排序(只根据第一个排序)
miao_hong_bin的专栏
01-19 1310
    /**     * ソット.     *      * @param downNo BigDecimal[]     * @param downPrice BigDecimal[]     * @return       */        //変数定義。    //BigDecimal[] downNo, downPrice;    //downNo = new BigDecimal[4
public class LuoxuanArray
u012402926的专栏
05-13 482
public class LuoxuanArray { 　　public static void main（String[] args）{ 　　int len=4; 　　int[][] arr=luoxuanStart（len）； 　　for（int i=0;i 　　for（int j=0;j 　　{ 　　System.out.print（+arr[i][j]+"\t"）； 　　}
Java笔记第十二课（数组排序及查找）
dreamer_96的博客
11-04 609
数组排序及查找 一.数组排序 1.选择排序法 思想：       数组的0索引依次和后面的索引进行比较,对应的元素小的往前方法,依次比较,就可以得到一个排好序的数组 例： public class ArrayDemo { public static void main(String[] args) { //定义一个数组,静态初始化 int[] arr =
Java数组排序-冒泡排序
weixin_41124484的博客
05-21 273
源码释义如下：public static void main(String[] args) { int a[] = { 12, 3, 44, 56, 67, 90, 73 }; // 冒泡排序口诀: 外层循环n-1;内层循环n-1-i;判断两个值大小,相互交换位置即可; for (int i = 0; i &lt; a.length - 1; i++) { for (int j = 0;...
arrays.sort排序二维数组
最新发布
09-28
可以使用Arrays类的sort方法来对二维数组进行排序。你可以使用传统的排序方法，即对二维数组的每一行进行排序，也可以使用自定义的比较器来指定排序规则。下面是二维数组排序的示例代码： 1. 对二维数组的每一行进行排序： ```java int[][] arr = { {5, 4, 3}, {2, 1, 6}, {9, 8, 7} }; // 对每一行进行排序 for (int i = 0; i < arr.length; i++) { Arrays.sort(arr[i]); } ``` 2. 使用自定义的比较器进行排序： ```java int[][] arr = { {5, 4, 3}, {2, 1, 6}, {9, 8, 7} }; // 定义自定义比较器 Comparator<int[]> comparator = new Comparator<int[]>() { @Override public int compare(int[] a, int[] b) { // 比较行的大小，如果相等再比较列的大小 if (a[0] != b[0]) { return a[0] - b[0]; } else { return a[1] - b[1]; } } }; // 使用自定义比较器进行排序 Arrays.sort(arr, comparator); ```
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值