实用类——JAVA
@月月鸟
枚举
- 枚举的定义
枚举是一种特殊的数据类型，之所以特殊是因为它既是一种类（class）类型却又比类型多了些特殊的约束，但是这些约束的存在也造就了枚举类型的简洁，安全性以及便捷性。创建枚举类型要使用enum关键字，隐含了所创建的类型都是java.lang.Enum类的子类（java.lang.Enum是一个抽象类）。枚举类型符合通用模式Class Enum
- 枚举的使用
创建一个枚举类：EnumTest
public enum EnumTest {
//星期一，星期二，星期三，星期四，星期五，星期六
MON(1), TUE(2),WED(3),THU(4),FRI(5),SAT(6){
public boolean isRest(){
return true;
}
},
//星期日
SUN(0){
public boolean isRest(){
return true;
}
};
private int value;
private EnumTest(int value){
this.value=value;
}
public int getValue(){
return value;
}
public boolean isRest(){
return false;
}
}
使用EnumTest枚举类：
public class EnumMain {
public static void main(String[] args) {
for (EnumTest enumTest : EnumTest.values()) {
System.out.println(enumTest + ":" + enumTest.getValue());
}
System.out.println("---------------我是分割线------------");
EnumTest test = EnumTest.SAT;
switch (test) {
case MON:
System.out.println("今天是星期一");
break;
case TUE:
System.out.println("今天是星期二");
break;
case WED:
System.out.println("今天是星期三");
break;
case THU:
System.out.println("今天是星期四");
break;
case FRI:
System.out.println("今天是星期五");
break;
case SAT:
System.out.println("今天是星期六");
break;
case SUN:
System.out.println("今天是星期日");
break;
default:
System.out.println(test);
break;
}
}
}
包装类
Java提供了两个类型系统，基本类型与引用类型，使用基本类型在于效率，然而很多情况，会创建对象使用，因为对象可以做更多的功能，如果想要我们的基本类型像对象一样操作，就可以使用基本类型对应的包装类，如下：
基本类型 对应的包装类（位于java.lang包中）
byte Byte
short Short
int Integer
long Long
float Float
double Double
char Character
boolean Boolean
拆箱和装箱
基本类型与对应的包装类对象之间，来回转换的过程称为”装箱“与”拆箱“：
装箱：从基本类型转换为对应的包装类对象。
构造方法:
Integer(int value) 构造一个新分配的 Integer 对象，它表示指定的 int 值。
Integer(String s) 构造一个新分配的 Integer 对象，它表示 String 参数所指示的 int 值。
传递的字符串,必须是基本类型的字符串,否则会抛出异常 “100” 正确 “a” 抛异常
静态方法:
static Integer valueOf(int i) 返回一个表示指定的 int 值的 Integer 实例。
static Integer valueOf(String s) 返回保存指定的 String 的值的 Integer 对象。
拆箱：从包装类对象转换为对应的基本类型。
成员方法:
int intValue() 以 int 类型返回该 Integer 的值。
用Integer与 int为例：
基本数值---->包装对象
Integer i = new Integer(4);//使用构造函数函数
Integer iii = Integer.valueOf(4);//使用包装类中的valueOf方法
包装对象---->基本数值
int num = i.intValue();
自动拆箱和装箱
由于我们经常要做基本类型与包装类之间的转换，从Java 5（JDK 1.5）开始，基本类型与包装类的装箱、拆箱动作可以自动完成。例如：
Integer i = 4;//自动装箱。相当于Integer i = Integer.valueOf(4);
i = i + 5;//等号右边：将i对象转成基本数值(自动拆箱) i.intValue() + 5;
//加法运算完成后，再次装箱，把基本数值转成对象。
基本类型转换为String
基本类型转换String总共有三种方式，查看课后资料可以得知，这里只讲最简单的一种方式：
基本类型直接与””相连接即可；如：34+""
Math数学工具类
包含用于执行基本数学运算的方法，如绝对值，对数，平方根和三角函数。它是一个final类，其中定义的都是一些常量和景甜方法。
常用方法如下：
补充：
1、Math.abs() 计算绝对值
package com.Java.Base;
public class Test_Math {
public static void main(String[] args) {
//Math常用方法
//sqrt开平方
System.out.println("Math.sqrt(4)="+Math.sqrt(4));
//ceil向上取整
System.out.println("Math.ceil(3.3)="+Math.ceil(3.3));
//floor向下取整
System.out.println("Math.floor(3.3)="+Math.floor(3.3));
//pow乘方
System.out.println("Math.pow(2,3)="+Math.pow(2,3));
//round四舍五入
System.out.println("Math.round(2.3)="+Math.round(2.3));
System.out.println("Math.round(2.5)="+Math.round(2.5));
//random() [0,1)
System.out.println("Math.random()="+Math.random());
}
}
Random三种随机数产生方法
- System.currentTimeMillis() 得到long型数字
- Math.random() 取值范围为[0,1)
- Random类产生一个随机数
Random类中实现的随机算法是伪随机的，即有规律的随机。随机时，随机算法的起源数字称为种子数seed,在种子数的基础上进行一定的变换，从而产生需要的随机数字。相同种子数的Random对象，相同次数生成的随机数字相同。
构造方法：
1、public Random() 默认种子数是不一样的
2、public Random(long seed) 自行设定seed
常用函数：
1、public void nextBytes(byte[] bytes)
2、public int nextInt()
3、public int nextInt(int n) 产生[0,5)之间的随机正数
4、public boolean nextBoolean()
5、public float nextFloat()
6、public double nextDouble()
String类的常用方法
- 用字符数组value创建一个String对象
. 方法：
public String(char[] value)
实例：
char[] value ={"a","b","c","d"};
String str = new String(value);
//相当于String str = newString("abcd")
- 用字符数组以x开始的n个字符创建一个String对象
方法：
public String(char chars[], int x, int n)
实例：
char[] value ={"a","b","c","d"};
String str = new String(value, 1, 2);
//相当于String str = newString("bc");
- 获取字符串长度
方法：
public int length()
实例：
String str = new String("478bhjd56");
int strlength = str.length();
- 获取字符串某一位置的字符
方法：
public char charAt(int index)
实例：
String str = new String("43dfzyd");
char ch = str.charAt(4);//ch = z
- 获取字符串的子串
方法：
public String substring(int beginIndex)
//该方法从beginIndex位置起，
//从当前字符串中取出剩余的字符作为一个新的字符串返回。
public String substring(int beginIndex, intendIndex)
//该方法从beginIndex位置起，从当前字符串中
//取出到endIndex-1位置的字符作为一个新的字符串返回。
实例：
String str1 = newString("asdfzxc");
String str2 = str1.substring(2);//str2 ="dfzxc"
String str3 = str1.substring(2,5);//str3 ="dfz"
- 字符串的比较
方法：
public int compareTo(String str)
//该方法是对字符串内容按字典顺序进行大小比较，
//通过返回的整数值指明当前字符串与参数字符串的大小关系。
//若当前对象比参数大则返回正整数，反之返回负整数，相等返回0。
public int compareToIgnoreCase (String str)
//与compareTo方法相似，但忽略大小写。
public boolean equals(Object obj)
//比较当前字符串和参数字符串，在两个字符串相等的时候返回true，否则返回false。
public boolean equalsIgnoreCase(String str)
//与equals方法相似，但忽略大小写。
实例：
String str1 = new String("abc");
String str2 = new String("ABC");
int a = str1.compareTo(str2);//a=32
int b = str1.compareToIgnoreCase(str2);//b=0
boolean c = str1.equals(str2);//c=false
boolean d =str1.equalsIgnoreCase(str2);//d=true
- 查找子串在字符串中的位置
方法：
public int indexOf(String str)
//用于查找当前字符串中字符或子串，返回字符或
//子串在当前字符串中从左边起首次出现的位置，若没有出现则返回-1。
public int indexOf(String str, intfromIndex)
//改方法与第一种类似，区别在于该方法从fromIndex位置向后查找。
public int lastIndexOf(String str)
//该方法与第一种类似，区别在于该方法从字符串的末尾位置向前查找。
public int lastIndexOf(String str, intfromIndex)
//该方法与第二种方法类似，区别于该方法从fromIndex位置向前查找。
- 字符串中字符的大小写转换
方法：
public String toLowerCase()
//返回将当前字符串中所有字符转换成小写后的新串
public String toUpperCase()
//返回将当前字符串中所有字符转换成大写后的新串
实例：
String str = new String("JavaStudy");
String str1 = str.toLowerCase();
//str1 = "javastudy"
String str2 = str.toUpperCase();
//str2 = "JAVASTUDY"
- 字符串两端去空格
方法：
String trim()
//去除字符串两端的空格，中间的空格不变，一般用于登陆注册时
实例：
String str = " z dali ";
String str1 = str.trim();
int a = str.length();//a = 8
int b = str1.length();//b = 6
System.out.println(a+"\n"+b);
- 将字符串分割成字符串数组
方法：
String[] split(String str)
实例：
String str = "sgs#jkc#eer";
String[] str1 = str.split("#");
for (int i = 0; i < str1.length; i++) {
System.out.println(str1[i]);
//输出结果是sgs jkc eer
}
- 基本类型转换为字符串
方法：
static String valueOf(xxx xx)
实例：
String s1 = String.valueOf(12.99);
System.out.println(s1);
//double类型转string类型
- 替换字符串
方法：
public String replace(char oldChar, charnewChar)
//用字符newChar替换当前字符串中所有的oldChar字符，
//并返回一个新的字符串。
public String replaceFirst(String regex,String replacement)
//该方法用字符replacement的内容替换当前字符串中遇到的
//第一个和字符串regex相匹配的子串，应将新的字符串返回。
public String replaceAll(String regex,String replacement)
//该方法用字符replacement的内容替换当前字符串中遇到的所有
//和字符串regex相匹配的子串，应将新的字符串返回。
实例：
String str = "hjdfjdskdd";
String str1 = str.replace('h','g');
//str1 ="gjdfjdskdd"
String str2 =str.replace("hj","xxx");
//str2 = "xxxdfjdskdd"
String str3 =str.replaceFirst("d","c");
//str3 = "hjcfjdskdd"
String str4 =str.replaceAll("hj","xxx");
//str4 = "xxxdfjdskdd"
System.out.println(str1+"\n"+str2+"\n"+str3+"\n"+str4);
String Buffer类
StringBuffer又称为可变字符序列，它是一个类似于 String 的字符串缓冲区，通过某些方法调用可以改变该序列的长度和内容。原来StringBuffer是个字符串的缓冲区，即就是它是一个容器，容器中可以装很多字符串。并且能够对其中的字符串进行各种操作。
创建一个字符串缓冲区对象。用于存储数据。
StringBuffer sb = new StringBuffer();
sb.append(“haha”); //添加字符串
sb.insert(2, “it”);//在指定位置插入
sb.delete(1, 4);//删除
sb.replace(1, 4, “cast”);//替换指定范围内的内容
String str = sb.toString();
注意：append、delete、insert、replace、reverse方法调用后，返回值都是当前对象自己，所以说，StringBuffer它可以改变字符序列的长度和内容。
对象的方法链式调用
在我们开发中，会遇到调用一个方法后，返回一个对象的情况。然后使用返回的对象继续调用方法。这种时候，我们就可以把代码现在一起，如append方法一样，代码如下：
创建一个字符串缓冲区对象。用于存储数据。
StringBuffer sb = new StringBuffer();
添加数据。不断的添加数据后，要对缓冲区的最后的数据进行操作，必须转成字符串才可以。
String str = sb.append(true).append(“hehe”).toString();
StringBuilder类
还有一个StringBuilder类，它也是字符串缓冲区，StringBuilder与它和StringBuffer的有什么不同呢？它也是一个可变的字符序列。此类提供一个与 StringBuffer 兼容的 API，但不保证同步。该类被设计用作 StringBuffer 的一个简易替换，用在字符串缓冲区被单个线程使用的时候（这种情况很普遍）。如果可能，建议优先采用该类，因为在大多数实现中，它比 StringBuffer 要快。
日期时间类
Date类
(1)基本概念
java.util.Date类用于描述特定的瞬间，可以精确到毫秒，通常描述年月日时分秒信息。
(2)常用的方法
Date() - 无参方式构造对象，默认使用当前系统时间来初始化该对象。
Date(long date) - 根据参数指定的毫秒数来构造对象。
- 参数为距离1970年1月1日0时0分0秒的毫秒数，1秒=1000毫秒 1毫秒=1000微秒
- 该方法与File类中的方法搭配使用很方便。
long getTime() - 用于获取调用对象距离1970年1月1日0时0分0秒的毫秒数。
void setTime(long time) - 根据参数指定的毫秒数来调整调用对象描述的时间。
import java.util.Date;
public class TestDate {
public static void main(String[] args) {
//1.使用无参的方式构造对象
Date dl = new Date();
System.out.println("dl = " + dl); //自动调用toString()系统时间
//2.使用有参的方式构造对象
Date d2 = new Date(1000);
System.out.println("d2 = " + d2); //1970年1月1日 08:00:01
System.out.println("-------------------------");
//3.使用有参的过时构造方法,来传入年月日时分秒
//Date d3 = new Date(2008-1900,8-1,8,20,8,8);
//System.out.println("d3 = " + d3);
System.out.println("-------------------------");
//使用getTime()方法和setTime()方法
long msec = dl.getTime();
System.out.println("当前系统时间距离1970年1月1日0时0分0秒的毫秒数："+msec);
Date d4 = new Date(msec);
System.out.println("d4 = " + d4);
d2.setTime(2000);
System.out.println("d2 = " + d2);
}
}
SimpleDateFormat类
(1)基本概念
java.text.SimpleDateFormat类用于实现Date类型和String类型之间的转换，调整日期格式
(2)常用的方法
SimpleDateFormat(String pattern) - 根据参数指定的格式来构造对象。
- 参数字符串中格式有：y-年 M-月 d-日 H-时 m-分 s-秒
String format(Date date) - 用于将Date类型转换为String类型并返回。
Date parse(String source) - 用于将String类型转换为Date类型并返回
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
public class TestSimpleDateFomat {
public static void main(String[] args) throws ParseException {
//1.按照默认方式打印日期
Date dl = new Date();
System.out.println("dl = " + dl); //打印默认日期格式
//2.按照指定的格式来打印日期
//SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日 HH时mm分ss秒");
//实现将dl的数值按照sdf中的格式来转换为String类型
String str = sdf.format(dl);
System.out.println(str);
//实现将str的数值按照sdf的格式转换为Date类型
Date d2 = sdf.parse(str);
System.out.println("d2 = " + d2);
}
}
Calendar类
(1)基本概念
java.util.Calendar类用于取代Date类中某些方法来描述年月日时分秒等信息。
(2)常用的方法
static Calendar getInstance() - 用于返回Calendar类型的对象。
void set(int year, int month, int date, int hourOfDay, int minute, int second)
- 将当前调用对象中的日期信息设置为参数指定的内容。
- 传入的月份要减1.
Date getTime() - 用于将Calendar类型转换为Date类型。
import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.Date;
public class TestCalendar {
public static void main(String[] args) {
//1.使用过时的构造方法可以传入年月日时分秒信息
Date dl = new Date(2008-1990, 8-1,8,20,8,8);
System.out.println("dl = " + dl);
System.out.println("---------------------");
//2.使用现在的方式传入年月日时分秒信息
//2.1 获取Calendar类型的对象
Calendar cl = Calendar.getInstance();
//2.2 设置年月日时分秒信息
cl.set(2008, 8-1,8,20,8,8);
//2.3 转换为Date类型的对象
Date d2 = cl.getTime();
System.out.println("d2 = " + d2);
System.out.println("----------------------");
//3.按照中国人的习惯打印日期信息
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
String str = sdf.format(d2);
System.out.println(str);
}
}
以上内容可能会有出入，仅供参考，部分出自转载，欢迎大家踊跃留言指正