实用类——JAVA

@月月鸟

枚举

• 枚举的定义

枚举是一种特殊的数据类型，之所以特殊是因为它既是一种类（class）类型却又比类型多了些特殊的约束，但是这些约束的存在也造就了枚举类型的简洁，安全性以及便捷性。创建枚举类型要使用enum关键字，隐含了所创建的类型都是java.lang.Enum类的子类（java.lang.Enum是一个抽象类）。枚举类型符合通用模式Class Enum<E extends Enum>，而E表示枚举类型的名称。枚举类型的每一个值都映射到protected Enum(String name,int ordinal)构造函数中，在这里，每个值的名称都转换成一个字符串，并且序数设置表示了此设置被创建的顺序。

• 枚举的使用

创建一个枚举类：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三种随机数产生方法

1. System.currentTimeMillis() 得到long型数字
2. Math.random() 取值范围为[0,1)
3. 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类的常用方法

1. 用字符数组value创建一个String对象
   . 方法：

public String(char[] value)

实例：

char[] value ={"a","b","c","d"};
String str = new String(value);
//相当于String str = newString("abcd")

2. 用字符数组以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");

3. 获取字符串长度
   方法：

 public int length()

实例：

String str = new String("478bhjd56");
int strlength = str.length();

4. 获取字符串某一位置的字符
   方法：

public char charAt(int index)

实例：

String str = new String("43dfzyd");
char ch = str.charAt(4);//ch = z

5. 获取字符串的子串
   方法：

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"

6. 字符串的比较
   方法：

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

7. 查找子串在字符串中的位置
   方法：

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位置向前查找。

8. 字符串中字符的大小写转换
   方法：

public String toLowerCase()
//返回将当前字符串中所有字符转换成小写后的新串

public String toUpperCase()
//返回将当前字符串中所有字符转换成大写后的新串

实例：

String str = new String("JavaStudy");
String str1 = str.toLowerCase();
//str1 = "javastudy"
String str2 = str.toUpperCase();
//str2 = "JAVASTUDY"

9. 字符串两端去空格
   方法：

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);

10. 将字符串分割成字符串数组
    方法：

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
}

11. 基本类型转换为字符串
    方法：

static String valueOf(xxx xx)

实例：

String s1 = String.valueOf(12.99);
System.out.println(s1);
//double类型转string类型

12. 替换字符串
    方法：

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);

    }

}

以上内容可能会有出入，仅供参考，部分出自转载，欢迎大家踊跃留言指正