Java 07 08 09

最新推荐文章于 2023-04-12 11:45:15 发布

Pointer_Z

最新推荐文章于 2023-04-12 11:45:15 发布

阅读量1.4w

点赞数

本文链接：https://blog.csdn.net/qq_45883111/article/details/106577398

版权

数组与排序

可以储存相同的数据类型引用类型
必须初始化分配空间给出初始化值
动态静态

public class Demo01 {
    public static void main(String[] args) {
        //动态 我们指定长度 系统给值
        int[] a=new int[10];
        //静态 相反
        int[] a1={1,8,9,45,3};
        //取值和赋值  会被分配角标 索引
        int b=a[0];
        //索引给值
        a[0]=99;
    }
}

常见操作最大最小

package com.kangsdan;

public class ArrayDemo {
    public static void main(String[] args) {
        int[] array={1,2,3,4,5,6};
        int temp=0;
        try {
            for (int i = 0; i <array.length; i++) {
                if(array[i]>temp){
                    temp=array[i];
                }
                System.out.println(array[i]);
            }
        } catch (Exception e) {
            System.out.println("越界了");
        }
        for (int i = array.length-1; i >0 ; i--) {
            System.out.println(array[i]);
        }
    }

}

反转

public class Change {
    public static void main(String[] args) {
        int[] arrays={1,2,3,4,5,6};
        int temp=0;
        int j=arrays.length-1;
        for (int i = 0; i < arrays.length/2; i++) {
            temp=arrays[i];
            arrays[i]=arrays[j];
            arrays[j--]=temp;//可以通过length-i-1；
        }
        for (int i = 0; i < arrays.length; i++) {
            System.out.print(arrays[i]+" ");
        }
    }
}

二维数组

public class Demo02 {
    //元素是一维数组的数组
    public static void main(String[] args) {
        int[][] arr2 = new int[][]{{1, 2, 3}, {2, 4, 6}};
        System.out.println(arr2[0][0]);
        int[] a = new int[]{1, 5, 6};
        int[][] arr=new int[3][3];
        System.out.println(arr);
        System.out.println(arr[0]);
        System.out.println(arr[0][2]);
        int[] g,z[] = new int[0][3];
        int b=z[0][0];
    }
}

public class YngHui {
    public static void yangHui(int a){
        int[][] kdd=new int[a][a];
        for (int i = 0; i < a; i++) {
            kdd[i][0]=1;
            kdd[i][i]=1;
        }
        for (int i = 2; i < a; i++) {
            for (int j = 1; j <i; j++) {
                kdd[i][j]=kdd[i-1][j]+kdd[i-1][j-1];
            }
        }
        for (int i = 0; i < a; i++) {
            for (int j = 0; j <= i; j++) {
                System.out.print(kdd[i][j]+"\t");
            }
            System.out.println();
        }
    }
    public static void main(String[] args) {
        yangHui(10);
    }
}//杨辉三角

public class Easy {
    public static void main(String[] args) {
        int[] a={1,5,8,6,7,6,45};
        int index=ge1id(a,5);
    }

    private static int ge1id(int[] a, int i) {
        for (int i1 = 0; i1 < a.length; i1++) {
            if(a[i1]==i){
                return i1;
            }
        }
        return -1;
    }
}

二分法查找

//二分查找前提是有序
public class TwoSearch {
    public static void main(String[] args) {
        int[] a={15,25,36,445,532,645};

        int index=getId(a,15);
        System.out.println(index);
    }

    private static int getId(int[] a, int i) {
        int minIdex=0;
        int maxIndex=a.length-1;
        int centerIndex=(maxIndex+minIdex)/2;
        while (minIdex<=maxIndex) {
            if(i==a[centerIndex]){
                return centerIndex;
            }else if(i>a[centerIndex]){
                minIdex=centerIndex+1;
            }else if(i<a[centerIndex]){
                maxIndex=centerIndex- 1;
            }
            centerIndex=(maxIndex+minIdex)/2;
        }

        return -1;
    }
}
//一直切换中间的对象

冒泡排序

public class MaoPao {
    public static void main(String[] args) {
        //冒泡排序，两两比较 议论后最大的放在最后
        int[] a={9,5,3,6,4,3};
        a=paiXu(a);
        for (int i:
             a) {
            System.out.println(i);
        }
    }

    private static int[] paiXu(int[] a) {
        int temp=0;
        for (int i = 0; i < a.length; i++) {
            for (int j = 0; j < a.length-1-i; j++) {//因为下面+1，所有小一  避免除法+1
                if (a[j]>a[j+1]){
                    temp=a[j];
                    a[j]=a[j+1];
                    a[j+1]=temp;
                }
            }
        }
        return a;
    }

}//前后比

选择排序

import java.util.Arrays;

public class XuanZhe {
    public static void main(String[] args) {
        int[] arr={24,69,5,1,78};
        Tuidao(arr);
    }

    private static void Tuidao(int[] arr) {
        for (int index=0;index<arr.length;index++) {
            for (int i = index; i < arr.length; i++) {
                if (arr[index] > arr[i]) {
                    int t = arr[index];
                    arr[index] = arr[i];
                    arr[i] = t;
                }
            }
        }
        System.out.printf( Arrays.toString(arr));
    }
}
//使用第一个和后面的比，找到第一个的位置

插入排序

//插入有序仍然保存有序

import java.util.Arrays;

public class ChaRu {
    //直接插入排序，从一索引处开始，将后面的元素，插入之前的有序列表中
    public static void main(String[] args) {
        kdd();
    }

    private static void kdd() {
        int[] a={5,9,2,6,4,6,3,44};
        //外层定义轮次
        for (int i = 0; i < a.length; i++) {
            //里层比较
            int j=i;
            while (j>0&&a[j]<a[j-1]){
                int t=a[j];
                a[j]=a[j-1];
                a[j-1]=t;
                j--;
            }
        }
        System.out.println(Arrays.toString(a));
    }
}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-kAx75kUW-1591358741502)(C:\Users\1\AppData\Roaming\Typora\typora-user-images\image-20200603100416833.png)]

希尔排序>插入

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-1FqN6OXK-1591358741505)(C:\Users\1\AppData\Roaming\Typora\typora-user-images\image-20200603100741958.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-CMicTK9p-1591358741506)(C:\Users\1\AppData\Roaming\Typora\typora-user-images\image-20200603101057894.png)]

import java.util.Arrays;

public class Shel {
    public static void main(String[] args) {
        //对插入的排序的优化
        //直接插入增量位1
        int[] arr={4,89,9,2,5,5};

        Cha(arr);

    }

    private static void Cha(int[] arr) {
        for (int h = arr.length/2; h > 0; h/=2) {
            for (int i = h; i <arr.length ; i++) {
                for (int j = i; j >h-1 ; j-=h) {
                    if(arr[j]<arr[j-h]){
                        int t=arr[j];
                        arr[j]=arr[j-h];
                        arr[j-h]=t;

                    }
                }

            }
        }
        System.out.println(Arrays.toString(arr));
    }
}
//使用言不好 可以使用克鲁特序列

int h=1;

while(h<=arr.length/3){h=h*3+1;}

快速排序

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-tnhgFAlK-1591358741508)(C:\Users\1\AppData\Roaming\Typora\typora-user-images\image-20200603104218743.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-tZRcXH76-1591358741509)(C:\Users\1\AppData\Roaming\Typora\typora-user-images\image-20200603105445151.png)]

归并排序

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-0EQCnqR3-1591358741513)(C:\Users\1\AppData\Roaming\Typora\typora-user-images\image-20200603105606501.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-wAvOFPZ2-1591358741515)(C:\Users\1\AppData\Roaming\Typora\typora-user-images\image-20200603105633756.png)]

import java.util.Arrays;

public class GuiBing {
    public static void main(String[] args) {
        int[] arr={9,4,5,7,53,4,85,7,8};
     //   int[] arr={4,5,7,8,1,2,3,6};
        //拆分
        chaiFen(arr,0,arr.length-1);

        //归并
       // guiBing(arr,0,3,arr.length-1);
        System.out.println(Arrays.toString(arr));
    }

    private static void chaiFen(int[] arr, int start, int end) {
        //计算中间索引
        int center=(start+end)/2;
        if(start<end){
            chaiFen(arr,start,center);
            chaiFen(arr,center+1,end);
            guiBing(arr,start,center,end);
        }
    }

    private static void guiBing(int[] arr, int star, int center, int end) {
        //定义一个临时数组
        int[] tempArray=new int[end-star+1];
        //定义左边数组的索引
        int i=star;
        //定义右边数组的索引
        int j=center+1;
        //定义临时数组的索引
        int index=0;
        while(i<=center&&j<=end){
            if(arr[i]<arr[j]){
                tempArray[index++]=arr[i++];
            }else {
                tempArray[index++]=arr[j++];
            }
        }
        //处理剩余元素
        while (i<=center){
            tempArray[index++]=arr[i++];
        }
        while (j<=end){
            tempArray[index++]=arr[j++];
        }
        //System.out.println(Arrays.toString(tempArray));
        //取回
        for (int k = 0; k < tempArray.length; k++) {
            arr[k+star]=tempArray[k];
        }
    }
}

基数排序

分配于收集就可以完成

Java08

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-dFJVM9kH-1591358741517)(C:\Users\1\AppData\Roaming\Typora\typora-user-images\image-20200603165741067.png)]

包装类（基本类型

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-qw2D81vo-1591358741518)(C:\Users\1\AppData\Roaming\Typora\typora-user-images\image-20200603165858226.png)]

在lang包下直接使用
自动装箱不是直接new 而是Valuof

import java.util.ArrayList;
import java.util.List;

public class Page {
    /*
    1.什么是包装类
    8种基本数据类型
    每种基本数据类型一一对应



    2.为什么需要
    类的形式提供对象
    字符串与基本数据联系的转换
    缺点
     */
    public static void main(String[] args) {
        List list=new ArrayList();
        list.add(3);//自动装箱/集合的数据类型不能用
        list.add(new Integer(3));//手动装箱
        System.out.println(Integer.MAX_VALUE);
        System.out.println(Integer.toBinaryString(12));
        System.out.println(Integer.toOctalString(12));
        System.out.println(Integer.toHexString(12));
        int i=Integer.parseInt("12364545");//网上注册，输入的都是字符串
        System.out.println(i+1);
        double d=Double.parseDouble("9.156");
        System.out.println(d);
        Integer i1=13;
        int i3=i1;//自动装箱和自动拆箱
        Integer i2=new Integer(5);//手动专向

        int i4=i2.intValue();//手动此项
        System.out.println(i4);
        Integer in1=new Integer(1314159);
        Integer in2=new Integer(1314159);
        Integer in3=5;//自动装箱 不是简单的使用 new Integer();
        Integer in4=5;
        System.out.println(in3.equals(in4));
        System.out.println(in3 == in4);

        System.out.println(in1.equals(in2));//比较的是数据
        System.out.println(in1 == in2);//比较的是地址
    }
    //运行时异常不需要处理，回自动抛出
    //检查异常必须进行异常处理
//可以实现基本类型与数据类型的转变
//

    //缺点
    //包装类需要专用栈内存和对堆内存
    //基本数据类型占用栈内存

/*
 public boolean equals(Object obj) {
        if (obj instanceof Integer) {
            return value == ((Integer)obj).intValue();
        }
        return false;
    }
 */
/*
public static Integer valueOf(int i) {
        if (i >= IntegerCache.low && i <= IntegerCache.high)
            return IntegerCache.cache[i + (-IntegerCache.low)];//若在-128到127 直接返回
        return new Integer(i);//如果在外需要创建对象
    }
 */
    /*
     private final int value;

     public Integer(int value) {
        this.value = value;
    }
     */
    /*
     static {
            // high value may be configured by property
            int h = 127;
            String integerCacheHighPropValue =
                sun.misc.VM.getSavedProperty("java.lang.Integer.IntegerCache.high");
            if (integerCacheHighPropValue != null) {
                try {
                    int i = parseInt(integerCacheHighPropValue);
                    i = Math.max(i, 127);
                    // Maximum array size is Integer.MAX_VALUE
                    h = Math.min(i, Integer.MAX_VALUE - (-low) -1);
                } catch( NumberFormatException nfe) {
                    // If the property cannot be parsed into an int, ignore it.
                }
            }
            high = h;

            cache = new Integer[(high - low) + 1];
            int j = low;
            for(int k = 0; k < cache.length; k++)
                cache[k] = new Integer(j++);

            // range [-128, 127] must be interned (JLS7 5.1.7)
            assert IntegerCache.high >= 127;
        }
     */
}

字符串的相关类

import java.util.Arrays;
/*
总结
length
toUperCase
toLowerCase
charAt
indexOf
concat
toCharArray()
substring
replace
 */
public class StringTest {
    public static void main(String[] args) {
        //创建字符串对象
        String s1="我喜欢你康丹丹LDD Dkdd    ";//不可变的，需要创建，改变引用
        String s2=new String("嗯嗯");
        //长度 大小写转换 判断其实字符串 结束 中间
        System.out.println(s1.length());//字符的个数，不是直接的个数
        System.out.println(s1.toUpperCase());
        System.out.println(s1.toLowerCase());//类型是不可变，他重新创建了应该空间
        System.out.println(s1.startsWith("我"));//开始
        System.out.println(s1.endsWith("d"));//结尾
        System.out.println(s1.contains("康丹丹"));//包含
        System.out.println(s1.charAt(1));
        System.out.println(s1.substring(2, 4));
        System.out.println(s1.substring(2));
        System.out.println(s1.indexOf("康"));
        System.out.println(s1.concat("赵朝进"));//拼接都是形成新的字符串
        System.out.println(s1.replace("康丹丹", "康丹"));
        System.out.println(s1.isEmpty());//判断是否为空  str="";//指向堆 str=null;//狗jb不是
        System.out.println(s1.replaceAll("D", "a"));
        System.out.println(s1.replace("D", "a"));
        char[] a=s1.toCharArray();
        System.out.println(s1.trim()+"hello");//去掉两端的空格
        int ai[]=new int[a.length];
        for (int i = 0; i < a.length; i++) {
            ai[i]=a[i];
        }
        System.out.println(Arrays.toString(ai));
    }
}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Ebppr6tn-1591358741519)(C:\Users\1\AppData\Roaming\Typora\typora-user-images\image-20200604123209292.png)]

==比较栈内存的内容

.equals值

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-z2LeUcFC-1591358741520)(C:\Users\1\AppData\Roaming\Typora\typora-user-images\image-20200605081907716.png)]

package com.kangsdan;

public class StringBuf {

    /*
    private final char value[];//底层是字符数组
    public String() {
        this.value = "".value;
    }
    //字符串在常量池中，将给堆内存中的value属性

     public String(String original) {
        this.value = original.value;
        this.hash = original.hash;
    }
     */

    /*public boolean equals(Object anObject) {
           if (this == anObject) {
                return true;
            }//引用相同，内容相同
            if (anObject instanceof String) {
                String anotherString = (String)anObject;//字符长度
                int n = value.length;//原始长度
                if (n == anotherString.value.length) {
                //获取底层的数组
                    char v1[] = value;
                    //同上
                    char v2[] = anotherString.value;
                    int i = 0;
                    while (n-- != 0) {
                        if (v1[i] != v2[i])
                            return false;
                        i++;
                    }

                    return true;
                }
            }
            长度不相同，直接返回错误
            return false;
        }
     */
    /*
    public String concat(String str) {
        int otherLen = str.length();
        if (otherLen == 0) {
            return this;
        }
        //获取原来的长度
        int len = value.length;
        char buf[] = Arrays.copyOf(value, len + otherLen);//在常量池中有新的创建
        str.getChars(buf, len);
        //追加的字符串
        return new String(buf, true);
    }
     */
    public static void main(String[] args) {
        String string=new String();
        String string1=new String("康丹丹赵朝进");
        System.out.println(string1.length());
        System.out.println(string1.isEmpty());
        System.out.println(string1.charAt(3));//value[3]
        String s=new String("康丹丹赵朝进");//常量池中就只有一次
        System.out.println(s == string1);//堆内存重新创建
        System.out.println(s.equals(string1));//常量池中就只有一次
        String s2="康丹丹";
        s2=s2.concat("abc");
        System.out.println(s2);
    }


}

/*
 public int compareTo(String anotherString) {
        int len1 = value.length;
        int len2 = anotherString.value.length;
        int lim = Math.min(len1, len2);
        char v1[] = value;
        char v2[] = anotherString.value;

        int k = 0;
        while (k < lim) {
            char c1 = v1[k];
            char c2 = v2[k];
            if (c1 != c2) {
                return c1 - c2;
            }
            k++;
        }
        return len1 - len2;
    }
 */
public class TestString {
    public static void main(String[] args) {
       // "".equals()判断对象的类容是否相同
        String s1="康丹丹";
        String s2="康丹丹";
        String s4="康丹丹A";
        String s5="康丹丹a";
        String s6="康丹丹AK";

        String s3=new String("康丹丹");
        System.out.println(s1.equals(s2));
        System.out.println(s1 == s2);
        System.out.println(s1.equals(s3));
        System.out.println(s1 == s3);
        //"".compareTo()比较对象大小是否相同
        System.out.println(s1.compareTo(s4));
        System.out.println(s4.compareTo(s5));
        System.out.println(s5.compareTo(s6));

        //字符串数组之间的转换
        char[] a=s6.toCharArray();
        /*
        public char[] toCharArray() {
        // Cannot use Arrays.copyOf because of class initialization order issues
        char result[] = new char[value.length];
        System.arraycopy(value, 0, result, 0, value.length);
        return result;
        }
         */
        String s = new String(a);
        String ss=new String(a,1,2);
        //引入StringBuffer StringBuilder
        String ss1=new String("abxc");
        ss1.concat("1");
        ss1.concat("2");//每次调用都会生成应该中间的字符串吗，会浪费空间，效率低下
        //String被设计为不可变字符串
        //要直接追加，需要考虑数组长度不够的问题
        System.out.println(ss1);
    }
}

Java 09

StringBuffer StringBuilder

package com.kangsdan;

public class TestStringBuilder {
    //底层都是数组
    public static void main(String[] args) {
/*
 AbstractStringBuilder(int capacity) {
        value = new char[capacity];//当上面是数值的时候
    }
 */
        /*
        public StringBuilder(String str) {
        super(str.length() + 16);
        append(str);
    }
         */
       //创建 StringBuilder
        StringBuilder stringBuilder = new StringBuilder("1223");//直接数值不一样
        stringBuilder.append(1223);

        stringBuilder.append("kdd");
        stringBuilder.append("1234567891234567");
        stringBuilder.append("123");
        System.out.println(stringBuilder);
        String ss= String.valueOf(stringBuilder);
        /*
        public static String valueOf(Object obj) {
            return (obj == null) ? "null" : obj.toString();
        }
         */
        /*
        public String toString() {
        // Create a copy, don't share the array
            return new String(value, 0, count);
         }
         */
        String ss1=stringBuilder.toString();
        System.out.println(ss == ss1);
        System.out.println(ss.equals(ss1));
        //追加
        stringBuilder.insert(3,3.15);
        System.out.println(stringBuilder);


        //删除

        stringBuilder.delete(3,7);
        System.out.println(stringBuilder);
        //修改
        stringBuilder.setCharAt(1,'1');
        stringBuilder.replace(1,3,"adadadd");
        System.out.println(stringBuilder);

        //反转
        System.out.println(stringBuilder.reverse());


        //转换
        //toString();
    }
}

package com.kangsdan;
/*
public StringBuilder append(String str) {
        super.append(str);
        return this;
    }/*
 */
/*
public AbstractStringBuilder append(String str) {
        if (str == null)
            return appendNull();
        int len = str.length();
        //扩容
        ensureCapacityInternal(count + len);
        str.getChars(0, len, value, count);
        count += len;
        return this;
    }
 */
/*
public void getChars(int srcBegin, int srcEnd, char dst[], int dstBegin) {
        if (srcBegin < 0) {
            throw new StringIndexOutOfBoundsException(srcBegin);
        }
        if (srcEnd > value.length) {
            throw new StringIndexOutOfBoundsException(srcEnd);
        }
        if (srcBegin > srcEnd) {
            throw new StringIndexOutOfBoundsException(srcEnd - srcBegin);
        }
        System.arraycopy(value, srcBegin, dst, dstBegin, srcEnd - srcBegin);//直接在后面追加1的内容
    }
 */
public class TestStringBuffer {
    public static void main(String[] args) {
        StringBuilder stringBuilder=new StringBuilder();
        System.out.println(stringBuilder.length());
        System.out.println(stringBuilder.capacity());
        stringBuilder.append("1212");
        System.out.println(stringBuilder.length());
        System.out.println(stringBuilder.capacity());
        stringBuilder.append("12124556465465");
        System.out.println(stringBuilder.length());
        System.out.println(stringBuilder.capacity());
    }
}/*
 public String toString() {
        // Create a copy, don't share the array
        return new String(value, 0, count);
    }*/

底层相同
先有StringBuffer 再有StringBulider
StringBuffer线程安全、性能低下（有锁
StringBuilder线程不安全性能高（无锁
java性能低下，和c语言向比较（每次运行class需要解释为机器码

Javap -c test

public class T1 {
    public static void main(String[] args) {
        String a="5454"+"sda";//字面常量编译的时候会优化，直接编译成为字符串
        String b=a+"sdd";//底层还是才用StringBuilder
        //System.out.println(b);
        for (int i = 0; i < 100; i++) {
            a+=i;//创建了多个StringBuilder
        }
        System.out.println(a);
        StringBuilder stringBuilder=new StringBuilder();
        for (int i = 0; i < 100; i++) {
            stringBuilder.append(i);//始终只有一个
        }
        System.out.println(stringBuilder.toString());
        System.out.println(stringBuilder);
    }
}

public class T1 {
    public static void main(String[] args) {
       StringBuilder a=new StringBuilder("A");
       StringBuilder b=new StringBuilder("B");
       mb_oper(a,b);
        System.out.println(a + "." + b);
    }

    private static void mb_oper(StringBuilder a, StringBuilder b) {
        a.append(b);
        b=a;
    }
}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-aXPHDeeY-1591358741520)(C:\Users\1\AppData\Roaming\Typora\typora-user-images\image-20200605114423844.png)]

import java.util.Scanner;

public class Test01 {
    public static void main(String[] args) {
        Scanner scanner=new Scanner(System.in);
        String a=scanner.nextLine();
        if(a.length()<6){
            System.out.println("长度小于6");
            return;
        }
        char[] b=a.toCharArray();
        for (int i = 0; i < b.length; i++) {
            if(b[i]>'0'&&b[i]<'9'||b[i]==' '){
                System.out.println("包含了错误类型");
                return;
            }
        }
        System.out.println(a);
        scanner.close();
    }
}

时间处理的相关类

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-jeDFBAgE-1591358741522)(C:\Users\1\AppData\Roaming\Typora\typora-user-images\image-20200605115430321.png)]

日期的date

util

import java.util.Date;

public class DateTest {
    //获取当前下单的时间，存到数据库
    public static void main(String[] args) {
        //获取当前的时间
        Date date=new Date();//1970-1-1 8:00:00   毫秒
        //public Date() {
        //        this(System.currentTimeMillis());
        //    }
        /*
        private transient long fastTime;
         */
        //输出下单的时间
        System.out.println(date.toString());
        System.out.println(date.toLocaleString());
        //认识过时的
        System.out.println(date.getYear());//1900+118
        System.out.println(date.getDay());//周几

        //没有过时的方法
        long da=date.getTime();//返回了毫秒数
        System.out.println(da);
    }
}

import java.sql.Date;

public class Datet {
    /*
    java.util.Date   YYYYMMDDHHMMSS
    java.sql.Date   YYYYMMDD
    java.sql.Time   HHMMSS
    java.sql.Tamp   YYYYMMDDHHMMSS
    都与数据库的操作有管
     */
    public static void main(String[] args) {
        //创建  sql没有无参数的构造
        Date now =new Date(System.currentTimeMillis());
        System.out.println(now);
        //方法  util没有方法
        Date date2=Date.valueOf("1999-12-23");//直接
        System.out.println(date2);
        //sql->date
        Date date=new Date(System.currentTimeMillis());
        System.out.println(date);
        java.util.Date up=date;
        java.util.Date up1=date2;//字类到父类
        //根据多态的原理，父类引用调用方法，如果字类重写，调用子类的方法
        System.out.println(up.toString());
        java.util.Date ud=new java.util.Date(date.getTime());//返回毫秒数
        System.out.println(ud);
        System.out.println(up1);
        //util->sql
        java.util.Date ud1=new java.util.Date();
        System.out.println(ud1);
        Date date1=new Date(ud1.getTime());
        System.out.println(date1);
    }
}

Date Formate

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

public class Simp {
    /*
    需求1：网页注册，网页所有的内容都是字符串 日期<->字符串
    需求2：后台有日期，注册成功后再网页上的日期
     */
    public static void main(String[] args) throws ParseException {
        //方法一  sql
//        Date date = Date.valueOf("1923-12-6");//太弱
//        System.out.println(date.toString());
        //方法
        int a=Integer.parseInt("23");
        //创建有管DateFormate
        DateFormat dateFormat=new SimpleDateFormat("yyyy-MM-dd");//mm代表分钟
        String av="1999-1-16";
        //字符串到日期。

        java.util.Date date1=dateFormat.parse(av);
        System.out.println(date1.toLocaleString());
//日期到字符串
        DateFormat dateFormat1=new SimpleDateFormat("yyyy年MM月dd日hh时mm分ss秒");
        String str =dateFormat1.format(date1);
        System.out.println(str);
    }
}

Calendar淘汰了Date

import java.util.Calendar;
import java.util.GregorianCalendar;

public class DateKING {
    public static void main(String[] args) {
        Calendar calendar=new GregorianCalendar();
        System.out.println(calendar.get(Calendar.YEAR));
        System.out.println(calendar.get(Calendar.MONTH));
        System.out.println(calendar.get(Calendar.DATE));
        System.out.println(calendar.get(Calendar.DAY_OF_WEEK));//周日是第一天
        calendar.set(Calendar.DATE,1);
        for (int i = 0; i < 35; i++) {
            calendar.add(Calendar.DATE,1);
            System.out.println(calendar.get(Calendar.DATE));
        }
        System.out.println(calendar.getActualMaximum(Calendar.DATE));
    }
}

枚举

public class Enums {
    private String name;
    private String sex;
    private int age;

    @Override
    public String toString() {
        return "Enums{" +
                "name='" + name + '\'' +
                ", sex='" + sex + '\'' +
                ", age=" + age +
                '}';
    }

    public static void main(String[] args) {
        Enums enums=new Enums();
        enums.age=11;
        enums.name="张三丰";
        enums.sex="男";
        System.out.println(enums.toString());
    }
}

win1.5提供

public enum Season {
    春,夏,秋,冬
}

public class TestSeason {


    public static void main(String[] args) {
        Season season=Season.冬;
        switch (season){
            case 冬:
                System.out.println("cloude");
                break;
            case 夏:
                System.out.println("热");
                break;
            case 春:
                System.out.println("安逸");
                break;
            case 秋:
                System.out.println("砍头");
        }
    }
}/*

*/

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-o1vldgt6-1591358741523)(C:\Users\1\AppData\Roaming\Typora\typora-user-images\image-20200605191244823.png)]

swith int short string char enum

import java.util.Random;

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

       System.out.println(Math.abs(-5));
       System.out.println(Math.round(3.5));//四舍五入
       System.out.println(Math.ceil(3.5));//取大
       System.out.println(Math.floor(3.5));//取小

       System.out.println(Math.max(20, 30));//最大值
       System.out.println(Math.min(15, 2));//最小
       System.out.println(Math.pow(3, 3));//平方
       System.out.println(Math.random());//0.0-1
       System.out.println(Math.sqrt(4));//开跟
       Random r=new Random(System.currentTimeMillis());
       for (int i = 0; i < 10; i++) {
           System.out.println(r.nextInt(10));
       }

   }
}


import java.util.Random;

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

       System.out.println(Math.abs(-5));
       System.out.println(Math.round(3.5));//四舍五入
       System.out.println(Math.ceil(3.5));//取大
       System.out.println(Math.floor(3.5));//取小

       System.out.println(Math.max(20, 30));//最大值
       System.out.println(Math.min(15, 2));//最小
       System.out.println(Math.pow(3, 3));//平方
       System.out.println(Math.random());//0.0-1
       System.out.println(Math.sqrt(4));//开跟
       Random r=new Random(System.currentTimeMillis());
       System.out.println("sda");
       /*
       [10,20]-->[10,21)-->10+[0,11)
        */
       /*
       int()强准
        */
       for (int i = 0; i < 10; i++) {
           System.out.println(r.nextInt(100));
       }

   }
}