JAVA part 10：数组、包装和Date类

JAVA part 10

数组

冒泡排序

举例：int[] arr = {24, 69, 80, 57, 13};
排序后：int[] arr = {13, 24, 57, 69, 80}

相邻元素两两比较，大的往后放
第一次比较，比较完毕后，最大值就出现在了最大索引处
第二次比较，比较完毕后，次大值就出现在了次大索引处

原理图：

代码：

package new_test;

public class mao_pao_pai_xu {
    public static void main(String[] args) {

        //定义一个int 类型的数组
        int[] arr = {24, 69, 80, 57, 13};

        for(int y=0; y<arr.length-1; y++){
            for(int x=0; x<arr.length-1-y; x++){
                if(arr[x]>arr[x+1]){
                    int temp = arr[x];
                    arr[x] = arr[x+1];
                    arr[x+1] = temp;
                }
            }
            printArray(arr);
        }
    }
    public static void printArray(int[] arr){
        System.out.print("[");
        for(int x=0; x<arr.length; x++){
            if(x==arr.length-1){
                System.out.print(arr[x]);
            }else{
                System.out.print(arr[x]+", ");
            }
        }
        System.out.println("]");
    }

Arrays类

Arrays提供了对数组的操作的各种和方法
public static String toString(int[] a); //把数组转成字符串
public static void sort(int[] a); //对数组进行升序排序

//用Arrays实现排序
package Day_10;

import java.util.Arrays;

public class test1 {
    public static void main(String[] args) {

        //定义一个数组
        int[] arr = {24, 69, 80, 57, 13};

        System.out.println("排序前"+ Arrays.toString(arr));

        //用Arrays对数组进行排序
        Arrays.sort(arr);
        System.out.println("排序后"+Arrays.toString(arr));
    }
}

Arrays的构造方法

通过查看源码发现：
private Arrays(){}

所以Arrays中的构造方法被private修饰，外界无法使用

要了解的是 Arrays类的这种设计常用的工具类的设计思想是：1.构造方法斯有；2.成员都用static修饰

基本包装类

为了对基本数据类型进行更多更方便的操作，JAVA就针对每一种剧本数据类型提供了一个对应的引用类型：
Byte---------------byte
Short--------------short
Integer------------int
Long---------------long
Float---------------float
Double------------double
Character---------char
Boolean-----------boolean

Integer类

Integer类在对象中包括了一个基本类型int的值

构造方法：
Integer(int value)
Integer(String s)

package Day_10;

public class test2 {
    public static void main(String[] args) {
        
        //Integer(int value)
        int s = 100;
        Integer i = new Integer(s);
        System.out.println(i);  //输出100
        
        //Integer(String s)
        String ss = "100";
        Integer ii = new Integer(ss);
        System.out.println(ii);
        
        /*
        //如果传入的是字符串会报错NumberFormatException
        String sss = "abc";
        Integer iii = new Integer(sss);
        System.out.println(iii);
         */
    }
}

int类型和String类型的转换

int------String
在String类中：public static String valueOf(int i);
String------int
在Integer类中：public static int parseInt(String s);

package new_test;

public class int_String_lei_xing_zhuan_huan {
    public static void main(String[] args) {

        //int ---- String
        int number = 100;
        //方式一：
        String s1 = ""+number;
        System.out.println(s1);
        //方式二：public static String valueOf(int i)
        String s2 = String.valueOf(number);
        System.out.println(s2);

        System.out.println("----------------");

        //String ---- int
        String x ="100";
        //方式一：String--Integer--int
        Integer i = new Integer(x);
        int y = i.intValue();
        System.out.println(y);
        //方式二：public static int parseInt(String x)
        int z = Integer.parseInt(x);
        System.out.println(z);
    }
}

自动装箱和自动拆箱

自动装箱：把基本数据类型转化成对应的包装类类型
public static Integer valueOf(int i)
自动拆箱：把包装类类型转换为对应的基本数据类型
public int intValue()

JAVA程序的运行：
编写JAVA文件----编译生成class文件—执行

package Day_10;
public class test3 {
    public static void main(String[] args) {

        //自动装箱:public static Integer valueOf(int i)
        Integer ii = 100;

        //自动拆箱+自动装箱:public int intValue()
        //ii为引用类型，将ii转化int类型后在进行自动装箱
        ii += 200;//ii = ii + 200;
        System.out.println(ii);

        /*
        Integer iii = null;
        iii += 300;//NullPointerException
        System.out.println(iii);
        */
    }
}

tips：
在使用包装类类型的时候，如果做操作，最好先判断是否问null

Data类

表示特定的瞬间，精确到毫秒

构造方法：
Date():
根据当前时间创建的日期对象
Date(long date):
根据给定的毫秒值创建对象，从1970年1月1日00:00:00开始

package Day_10;

import java.util.Date;

public class test4 {
    public static void main(String[] args) {
        
        //Date()
        Date d =new Date();
        System.out.println(d);
        
        //Date(long date)
        long date = 1000*60*60;
        Date dd = new Date(date);
        System.out.println(dd);
    }
}

Date类的getTime()和setTime()

public long getTime()：
获取的是毫秒值，从1970年1月1日00:00:00开始的
public void setTime()：
设置时间，给的是毫秒值

package Day_10;

import java.util.Date;

public class test5 {
    public static void main(String[] args) {
        
        //创建对象
        Date d = new Date();
        //public long getTime()
        System.out.println(d.getTime());
        //public void setTime(long time)
        d.setTime(1000*60*60);
        System.out.println(d.getTime());
    }
}

SimpleDateFormat类

是一个与语言环境有关的方式来格式化和解析日期的具体类
它允许惊醒格式化（日期–>文本）、解析（文本–>日期）

格式化（日期–>文本）：Date—String
public final String format(Date date)

package Day_10;

import java.text.SimpleDateFormat;
import java.util.Date;

public class test6 {
    public static void main(String[] args) {

        //Date---String
        Date d = new Date();
        //SimpleDateFormat(String pattern):用给定的格式
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日hh:mm:ss");
        String s =sdf.format(d);
        System.out.println(s);
    }
}

解析（文本–>日期）：String — Date
public Date parse(String source)

package Day_10;

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;

public class test7 {
    public static void main(String[] args) throws ParseException {
        
        //String--Date
        String str = "2080-08-08 12:23:45";
        SimpleDateFormat sdf = new SimpleDateFormat("yyyyy-MM-dd HH:mm:ss");
        Date d = sdf.parse(str);
        System.out.println(d);
    }
}

tips:
把一个字符串解析为日期的时候，请注意模式字符串和给定的日期字符串的格式要匹配