枚举和常用类

枚举

枚举是一种特殊的类,是一种数据类型,表示可罗列的的常量值

这些值是public static final 的

枚举类中可以用中文,建议大写

没有枚举类的时候这么写,私有化无参构造

public class User {
    private String name;
    private User gender;
    public static final User MEN = new User();
    public static final User WOMEN = new User();

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public User getGender() {
        return gender;
    }

    public void setGender(User gender) {
        this.gender = gender;
    }

    public User(String name, User gender) {
        this.name = name;
        this.gender = gender;
    }

    private User() {
    }
}

//枚举类的常用形式
public class user01 {
    public class User {
        private String name;
        private Gender gender;

        public String getName() {
            return name;
        }

        public void setName(String name) {
            this.name = name;
        }

        public Gender getGender() {
            return gender;
        }

        public void setGender(Gender gender) {
            this.gender = gender;
        }

        public User(String name, Gender gender) {
            this.name = name;
            this.gender = gender;
        }

        public User() {
        }
    }

}
enum Gender{
    MAN,
    WOMAN;
}

包

为了解决同名类的问题,也可以看成目录

包的作用:防止类命名冲突2.更好的组织类,方便管理维护3.可以保护类.属性.方法(包访问权限)

注意:

必须放在有效代码的第一行

全部使用小写,符合命名规则和规范

父包和子包用.分割

自定义包名不能使用java关键字作为包名

命名原则:一定保持唯一性

1.小写字母组成,不能用圆点开头或者结尾

2.之前最好加上唯一的前缀,通常使用组织倒置的网络域名

3.包名后缀部分依不同机构内部的规范不同而不同

总结:

当一个类中用到其他类A,首先去该类所在的包查找,如果找到,不再继续查找;如果找不到,尝试通过import关键字去查找,如果还找不到,报错

包名加类名叫做全路径,专门用于查找一个类

使用的类不在本包的时候需要导包

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

import的作用:

1.导入wolfcode01.test2.Teacher类

2.并命名简名Teacher

不同包中的同名类

解决方法

1.用全路径解决

2.一个用简名,一个用全路径

常用类

常用类是把经常使用的功能,通过面向对象的思维封装成类,想完成什么功能就找相应的类创建对象即可.

学习方法:

1.了解该类的特性以及行为(提供的常用方法),方法一定要多练习,总结,看API

2.练熟后,通过该类反思其面向对象的知识

工具类的设计

把那些完成通用功能的方法分类存放到类中,这就叫做工具类,一般以Util/Utils/Tool/Tools结尾

设计方式：公共静态方法实现工具类设计，单例模式设计等

会把所有的常用的工具类放到工具包中,一般以util/utils/tool/tools等命名

工具类一般不用来创建对象

总结:

工具类就是为了完成通用性的功能设计的,目的不在于让其对象持有数据,所以一般私有化构造器

单例模式(只有一个实例)

是一套反复使用的代码设计经验总结,专门用于解决特定场景的需求,实用设计模式是为了可重用代码.让代码更容易被他人理解,保证代码的可靠性

目的:保证在整个应用中某一个类有且只有一个实例(一个类在堆内存中只存在一个对象)

1.构造方法私有化

2.创建一个对象,保证其唯一性,同时暴露给外界使用,外界通过方法统一获取单例

3.在单例上,可以把通用性的数据和功能都放到单例上

//懒汉式单例模式,只有在调用方法的时候才会创建对象,叫做延迟创建.好处是不浪费空间,但是用的时候效率会低,线程是不安全的
public class Singleton{
    
    private static Singleton singleton = null;
    //1.私有化构造方法
    private Singleton(){}
    //2.创建一个对象,保证其 唯一性,同时暴露给外界使用
    public static Singleton getInstance(){
        if (null == singleton){
            singleton = new Singleton();
        }
        return singleton;
    }
    //3.在单例上,可以把通用性的数据和功能都放到单例上
    public  String array2String(int[] array){
        String str = "[";
        int len = array.length;
        for (int i = 0; i < len; i++) {
            str += array[i];
            if (i == len - 1){
                str += "]";
            } else {
                str += ",";
            }
        }
        return str;
    }
}

//饿汉式,一开始就创建一个对象以供使用,在类被加载到虚拟机的时候就已经创建好对象,如果没有用到其中的方法的话就会造成资源浪费.线程是安全的

public class Singleton{
    
    private static final Singleton instance = new Singleton();
    //1.私有化构造方法
    private Singleton(){}
    //2.创建一个对象,保证其 唯一性,同时暴露给外界使用
    public static Singleton getInstance(){
        return instance;
    }
    //3.在单例上,可以把通用性的数据和功能都放到单例上
    public  String array2String(int[] array){
        String str = "[";
        int len = array.length;
        for (int i = 0; i < len; i++) {
            str += array[i];
            if (i == len - 1){
                str += "]";
            } else {
                str += ",";
            }
        }
        return str;
    }
}

//枚举式(特殊饿汉式)
public enum SingletonEnum{
    INSTANCE;
    
    public  String array2String(int[] array){
        String str = "[";
        int len = array.length;
        for (int i = 0; i < len; i++) {
            str += array[i];
            if (i == len - 1){
                str += "]";
            } else {
                str += ",";
            }
        }
        return str;
    }
}

包装类

被基本数据类型封装到一个类中,提供属性和方法,让开发者更方便的操作基本数据类型

Integer和int,Integer和String之间可以相互转换

Integer是int和String之间转换的桥梁

区别：基本数据类型在栈区,包装类在堆区,

基本数据类型不能调用方法,包装类可以调用已经有的字段和方法

装箱和拆箱

装箱:把基本数据类型转换为对应的包装类的过程

拆箱:把包装类转换为对应的基本数据类型的过程

自动拆箱(int value2 = i;)把包装类直接赋值给对应的基本数据类型

自动装箱(Integer i = 20;):直接把基本数据类型赋值给对应的包装类的过程

   Integer i1 = Integer.valueOf(10);
        
        //自动装箱
        Integer i2 = 20;
        //自动拆箱
        int value2 = i2;
    

在jdk中,如果一个方法可以直接返回一个该类型的对象,我们把这样的方法叫做工厂方法,integer类在加载到jvm时,内部初始化好了一个缓存区Integer[] cache,缓冲区integer地向的范围为[-128,127],节省了integer的内存,可以提高性能

public static void main(String[] args) {
        Integer i1 = new Integer(10);
        Integer i2 = new Integer(10);
        System.out.println(i1 == i2);
        Integer i3 = Integer.valueOf(20);
        Integer i4 = Integer.valueOf(20);
        System.out.println(i3 == i4);
        Integer i5 = 30;
        Integer i6 = 30;
        System.out.println(i5 == i6);
        Integer i7 = Integer.valueOf(300);
        Integer i8 = Integer.valueOf(300);
        System.out.println(i7 == i8);
        Integer i9 = 300;
        Integer i10 = 300;
        System.out.println(i9 == i10);
    }

BigDecimal

专门用于处理金钱或者任意高精度小数算法

只有BigDecimal(String str)可以进行高精度计算,

基本操作:

        /*BigDecimal num1 = new BigDecimal(0.09);
        BigDecimal num2 = new BigDecimal(0.01);
        BigDecimal add = num1.add(num2);
        System.out.println(add);*/
        BigDecimal num1 = new BigDecimal("0.09");
        BigDecimal num2 = new BigDecimal("0.01");
        System.out.println(num1.add(num2));

精度控制:

        BigDecimal num3 = new BigDecimal("0.344");
        BigDecimal num4 = new BigDecimal("2.0");
//保留两位小数,四舍五入
        System.out.println(num3.multiply(num4).setScale(2, RoundingMode.HALF_UP));

        BigDecimal num5 = new BigDecimal("10.0");
        BigDecimal num6 = new BigDecimal("3.0");
//保留三位小数,四舍五入
        System.out.println(num5.divide(num6, 3, RoundingMode.HALF_UP));

String

不可变字符串:string,创建对象之后,内容不能改变,String在内存中是以字符数组的形式存在的

可变的字符串:StringBuilder/StringBuffer

String是字符数组的包装类,提供只读的形式操作其包装的字符数组的方法

字符串的两种创建方式

1.字面量创建

String str = “abc”;

通过字面创建的字符串分配在常量池中,字面量字符串是常量(1.8之后在堆区有一块专门的内存来存放,之前的时候在内存中有一个专门的内存用来存放)

当字符串在常量池创建字符串的时候,先在常量池查找有没有创建过,如果创建过,直接把地址给到变量

2.new操作

String str2 = new String(“abc”);

new操作创建的在堆区,不管内容是否一样,都会申请一块新的地址

当String类型的对象创建完毕之后

比较是否相等

比较忽略大小写是否相等

字符串比较

//需求:控制台输入验证码?判断验证码是否正确?
Scanner sc = new Scanner(System.in);
        String validcode = "F4as";
        System.out.println("请输入验证码" + validcode);
        String inputStr = sc.next();
        if (inputStr.equalsIgnoreCase(validcode)){
            System.out.println("验证码正确");
        } else {
            System.out.println("验证码错误");
        }

字符串查找:

1.是否包含某个字符串contains

2.判断以XX为前缀或者后缀endsWith/startWith

3.找元素在字符串中第一次出现的位置indexOf(int ch)/indexOf(int ch,fromIndex)

indexOf(String str)/indexOf(String str,fromIndex)

lastIndexOf从右向左查找,找到字符第一次出现的索引位置

字符串替换:

替换单个字符replace(oldch,newch)

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

字符串分隔,求子字符串

split(),按照给定的东西分隔,返回值为字符串数组

//替换手机号码186-2001-1234
String phone = "186-2001-1234";
System.out.println(phone.replace('-','\u0000'));
System.out.println(phone.replace("",""));
String[] strArr = phone.split("-");
String str = "";
for(Strint item : strArr){
    str += item;
}
str.sout;

//构建一个字母表
String str = "abcdefg";
String[] strArr = str.split("");
for(Strint item : strArr){
    item + " ".sout
}

截取字符串:

只要在java中,遇到start,end/startIndex,endIndex/from,to/fromIndex,endIndex/都是含头不含尾的

指定位置字符

charAt(index)

字符串连接:

+/concat

字符串长度

str.length

字符串是不是为空

isEmpty

大小写转换

toUpperCase/toLowerCase

去掉字符串前导和后导空格

trim去掉字符串前边的空格和后边的空格,中间的去不了

工厂方法

valueOf把八大基本数据类型转换为字符串

字符串陷阱:

遍历数组的时候不要用+=数组,会产生很多的临时内存空间用来存放运行过程中产生的数据(比如创建字母表的例子)

        String string = "hello world";
        System.out.println(string.charAt(0));
        System.out.println(string.length());
        System.out.println(string.isEmpty());
        String string1 = string.toUpperCase();
        System.out.println(string1);
        String string2 = string1.toLowerCase();
        System.out.println(string2);
        String str = "    asb   ";
        System.out.println(str.trim());
        String string3 = String.valueOf(100.0);
        System.out.println(string3);
        System.out.println(string3.length());

可变字符串

可以解决字符串陷阱问题

如果要对包装的字符数组进行增删改查时,就要用到可变字符串

StringBuilder/StringBuffer

StringBuffer(线程安全)可以看成是一个包装类,包装了一个字符数组,完全可以把StringBuffer看成一个容器(核心功能:增删改查)

StringBuffer封装的数组默认的是16个字符,超过默认空间时,自动扩容

StringBuffer构造方法:

StringBuffer()构造不带字符的默认缓冲区的可变字符串,长度为16个字节

StringBuffer(int a)构造一个不带字符,指定初始容量的字符串缓冲区(如果已知长度就指定长度)

append(追加)/insert(指定位置加)

capacity()获取容量

length()获取长度

insert(位置,加的内容)

        StringBuffer string = new StringBuffer();
        string.append("hello");
        string.append(100);
        string.append('q');
        System.out.println(string);
        System.out.println(string.length());
        System.out.println(string.capacity());
        string.insert(0,'p');
        System.out.println(string);
        string.insert(6,"wer");
        System.out.println(string);

delete(删除)

replace(修改)(start,end,string)

setCharAt(index,char)修改某一个位置的元素

链式操作

sb.append(“hello”).append(“world”);

public Dog showInfo(){
        System.out.println("wangwnagw");
        return this;
    }
    
    public Dog sayHi(){
        System.out.println("hello");
        return this;
    }

拓容机制(要申请新数组)

容量不够的时候自动增加容量,增加的值为原来的容量×2+2

不知道字符多长的时候触发自动拓容机制,但是一定要记得裁减掉多余的空间

trimToSize(裁剪多余的空间)

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

单线程的情况下优先选用StringBulider;jdk1.5出现的;线程不安全,效率高

多线程下使用StringBuffer;jdk1.0出现的,线程安全,但是效率高

Math

ceil(向上取整,大于等于的最小整数值)/floor(向下取整,小于等于的最大整数)

求最大值(max(a,b)),最小值

random 范围[0.0,1.0),随机数

[m,n]的随机数公式

(int)(Math.random() * (n - m + 1 )) + m;

//产生验证码,控制台输入
public static void main(String[] args) {
        //随机产生验证码
        String string = "qwertyuiopasdfghjklzxcvbnm1234567890QWERTYUIOPASDFGHJKLZXCVBNMM我爱你中国";
        StringBuilder sb = new StringBuilder();
        int index = -1;
        for (int i = 0; i < 4; i++) {
            index = (int)(Math.random() * (string.length() - 1 - 0 + 1) + 0);
//index = new Random().nextInt(string.length());

            sb.append(string.charAt(index));
        }
        System.out.println(sb);
        Scanner sc = new Scanner(System.in);
        String input = sc.next();
        if (input.equalsIgnoreCase(String.valueOf(sb))){
            System.out.println("输入正确");
        } else {
            System.out.println("输入错误");
        }
    }

util包的random

特别适合于[0,m)

public static void main(String[] args) {
        Random random = new Random();
        for (int j = 0; j < 20; j++) {
            int i = random.nextInt(100);
            System.out.println(i);

        }
    }

UUID表示通用的唯一标识符,优点是真实的唯一性,缺点是太长了

一般用于产生商品的编码,比如手机序列号,长度为36位

public static void main(String[] args) {
        UUID uuid = UUID.randomUUID();
        System.out.println(uuid);
        System.out.println(uuid.toString());
        String str = uuid.toString();
        str = str.replace("-","");
        System.out.println(str);
    }

日期时间

时间戳(timestamp):具体的时间距离历元1970年1月1日00:00:00:000经过的毫秒数,用long类型存储

Date在util包,内部包装了fasttime

//根据当前系统,当前时区获取当前时间
Date now = new Date();
//创建一个时间表示明天的此时
long ts1 = now.getTime();
long ts2 = ts1 + 24 * 60 * 60 * 1000;
Date tomorrow = new Date(ts2);

//格式化时间SimpleDateFormat
SimpleDateFormat sp = new SimpleDateFromat("yyyy年MM月dd日 HH:mm:ss");
Date now = new Date();
String dateStr = sp.format(now);
//解析时间,把日期时间字符串转换成日期时间对象,一定要一一对应,保证格式一模一样
String str = "2021年03月23日 17时22分02秒";
        SimpleDateFormat sp1 = new SimpleDateFormat("yyyy年MM月dd日 HH时mm分ss秒");
//sp.applyPattern("yyyy年MM月dd日 HH时mm分ss秒")
        System.out.println(sp1.parse(str));

1970年1月1日00:00:00:000经过的毫秒数,用long类型存储

Date在util包,内部包装了fasttime

//根据当前系统,当前时区获取当前时间
Date now = new Date();
//创建一个时间表示明天的此时
long ts1 = now.getTime();
long ts2 = ts1 + 24 * 60 * 60 * 1000;
Date tomorrow = new Date(ts2);

//格式化时间SimpleDateFormat
SimpleDateFormat sp = new SimpleDateFromat("yyyy年MM月dd日 HH:mm:ss");
Date now = new Date();
String dateStr = sp.format(now);
//解析时间,把日期时间字符串转换成日期时间对象,一定要一一对应,保证格式一模一样
String str = "2021年03月23日 17时22分02秒";
        SimpleDateFormat sp1 = new SimpleDateFormat("yyyy年MM月dd日 HH时mm分ss秒");
//sp.applyPattern("yyyy年MM月dd日 HH时mm分ss秒")
        System.out.println(sp1.parse(str));