概述
枚举
枚举是一种特殊的类,是一种数据类型,表示可罗列的的常量值
这些值是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:Users86188AppDataRoamingTyporatypora-user-imagesimage-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:Users86188AppDataRoamingTyporatypora-user-imagesimage-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:Users86188AppDataRoamingTyporatypora-user-imagesimage-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));
最后
以上就是雪白自行车为你收集整理的枚举和常用类的全部内容，希望文章能够帮你解决枚举和常用类所遇到的程序开发问题。
如果觉得靠谱客网站的内容还不错，欢迎将靠谱客网站推荐给程序员好友。
发表评论 取消回复