常用工具类
1 错误处理：
1.1 自定义异常
public class CustomException extends Exception{
public CustomException(){
//无参，有时会用到
}
public CustomException(String message){
super(message);
}
}
1.2 捕获异常转换成另外一种异常抛出
package com.lxj;
import com.lxj.Test;
public class HelloWorld {
private int cc = 99;
public static void main(String[] args){
try{
HelloWorld h = new HelloWorld();
h.test2();
}catch(Exception e){
e.printStackTrace();
}finally{
System.out.println("结束了")
}
}
public void test1() throws Exception{
throw new Exception("牛逼");
}
public void test2() throws Exception{
try{
this.test1();
}catch(Exception e){
//RuntimeException r = new RuntimeException(e); //不转换异常类型，不改变里面的异常提示
RuntimeException r = new RuntimeException("runtime 异常"); //转换异常类型，改变里面异常信息
r.initCause(e);
throw r;
}
}
}
2 java中的字符串
2.1 比较字符串值是否相等要用equals，==比较的是内存地址
2.2 java中String new和直接赋值的区别:
new，会在java的堆内存中创建对象, 有几个new就有几个对象。直接赋值, 是从字符串常量池中取值。
例如 String str1 = "a"; String str2 = "a"; System.out.println(str1==str2);结果为true,地址值都是字符串长量池中的"a".
String str3 = new String("a");String str4 = new String("a");System.out.println(str3==str4);结果为false. 应为new会在堆中创建两个字符串对象, 地址值不同
2.3 常用方法：
int length() : 返回当前字符串长度
int indexOf(int ch) :查找ch字符在该字符串中第一次出现的位置
int indexOf(String str):查找str字符串在该字符串中第一次出现的位置
int lastIndexOf(int ch):查找ch字符在该字符串中最后一次出现的位置
int lastIndexOf(Sting str):查找str字符串在该字符串最后一次出现的位置
String substring(int beginIndex) ：获取从beginIndex位置开始到结束的子字符串 【注】：包含beginIndex位置字符
String substring(int beginIndex,int endIndex) :获取从beginIndex位置开始到endIndex位置结束的子字符串 【注】：包含beginIndex位置字符，不包含endIndex位置字符
String trim() :去除字符串前后空格
boolean equals(Object obj) : 将字符串与指定对象比较
String toLowerCase():将字符串全转为小写
String toUpperCase():将字符串全转为大写
char charAt(int index) :获取字符串中指定位置的字符
String[] split(String regex,int limit) :将字符串分割为子字符串，返回字符串数组
byte[] getBytes():将字符串转为byte数组
byte例子：
String str = "haha niubi";
byte[] b = str.getBytes();
for(int i=0;i<b.length;i++){
System.out.print(b[i]+" ");
}
//104 97 104 97 32 110 105 117 98 105
2.3 StringBuffer、StringBuilder(StringBuilder实现了线程安全性能更高)：
2.3.1 相对于普通定义字符串，如果定义一个字符串在重新使其改变值，普通定义的字符串会另开辟空间，而这两个类会直接修改元内存地址值，不需要另开辟空间
2.3.2 定义StringBuilder类：
StringBuilder str1 = new StringBuilder();
StringBuilder str2 = new StringBuilder("哈哈哈");
System.out.println(str2); //哈哈哈
2.3.3 StringBuilder类常用的方法：
StringBuilder append():当前字符串后拼接
StringBuilder insert(位置,内容)：将要插入的字符串插入指定位置
String toString():转为字符串
int length() :获取字符串长度
3 java中的包装类 ：基本数据类型(byte、short、int、long、float、double、char、blean)不具备对象类型，比如不能调用方法，为了让他们能调用java提供了包装类
【注】：在 JDK1.5 引入自动装箱和拆箱的机制后，包装类和基本类型之间的转换就更加轻松便利了。
以int为例子：
3.1 装箱：把基本类型转换成包装类，使其具有对象的性质，又可分为手动装箱和自动装箱
如：int i =10;
Integer x = new Integer(i); //手动装箱
Integer y = i ; //自动装箱
int z = i + x ;// 20 将基本数据类型与对象计算
3.2 拆箱：和装箱相反，把包装类对象转换成基本类型的值，又可分为手动拆箱和自动拆箱
Integer j = new Integer(8);//定义一个Integer包装类对象,值为8
int m = j.intValue();//手动拆箱为int类型
int n = j;//自动拆箱为int类型
4 java中基本数据类型与字符串相互转换：
4.1 基本数据类型转换为字符串：
int a = 2;
4.1.1 toString ：
String str1 = Integer.toString(a);
4.1.2 valueOf:
String str1 = String.valueOf(a);
4.1.3 用一个空字符串加上基本数据类型，得到的就是基本类型数据对应的字符串:
String str3 = a + "";
4.2 字符串转换为基本数据类型：
String str = "9";
4.2.1 ：调用包装类的parseXxx静态方法
int d = Integer.parseInt(str);
4.2.2 : 调用包装类的valueOf方法转换为基本类型的包装类,会自动拆箱
int e = Integer.ValueOf(str);
5 Date与SimpleDateFormat、Calendar类表示时间：
5.1 Date:java.util.Date ,最主要用来获取当前时间
Date d = new Date();
System.out.println(d);
5.2 SimpleDateFormat:java.text.SimpleDateFormat,用来格式化时间
5.2.1 format:将日期转化为指定文本格式显示
Date d = new Date();
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
String today = sdf.format(d);
5.2.2 parse:将文本转换为日期
String day = "2017年08月11日 11点21分00秒";
SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日 HH时mm分ss秒");
Date date = sdf.parse(day);
5.3 Calendar:java.util.Calendar ,Date设计缺陷，不建议使用Date，建议使用Carlendar代替Date,Carlendar是个抽象类，通过调用内部getInstance获取Calendar对象
Calendar c = Calendar.getInstance();
int year = c.get(Calendar.YEAR);
int month = c.get(Calendar.MONTH) + 1; //0代表1月
int day = c.get(Calendar.DAY_OF_MONTH);
int hour = c.get(Calendar.HOUR_OF_DAY);
int minute = c.get(Calendar.MINUTE);
int second = c.get(Calendar.SECOND);
System.out.println(year + "-" +month + "-" +day + " " +hour + ":" +minute + ":" +second); //2017-8-11 11:43:42
6 Math ：用来计算的类
6.1 常用方法：
long round():四舍五入取整
double floor():去尾法取整
double ceil():进一取整
double random():随机数0~1 例：产生[0,99)(包含0不包含99)之间的随机整数 ：(int)(Math.random() * 99)
7 集合(Collection、Map):
7.1 Collection:
7.1.1 : List(序列) :有序的，可以重复的
实现类
7.1.1.1 :ArrayList（数组序列）
7.1.1.2 :LinkedList(链表)
7.1.2 : Queue（队列） ：有序的，可以重复的
实现类
7.1.2.1 :LinkedList(链表)
7.1.3 : Set(集)：无序的，不可重复的
实现类
7.1.3.1 :Hashset
7.2 Map:
实现类
7.2.1 HashMap
7.3 Collection下的List之ArrayList
7.3.1 add:
Course cr1 = new Course("1","数据结构");
//添加到序列
this.coursesToSelect.add(cr1);
//从序列中取出
Course temp = (Course) this.coursesToSelect.get(0); //对象存入集合(collection、map)都变成了object类型，取出来时候要类型转换，向下转型
System.out.println(temp.id + "_" +temp.name); //1_数据结构
Course cr2 = new Course("2","C语言");
this.coursesToSelect.add(0,cr2); //在list最开始添加数据
Course temp2 = (Course) this.coursesToSelect.get(0);
System.out.println(temp2.id + "_" +temp2.name); //1_数据结构
//如果现在list中有2个元素，这时候只能像第3个元素插入，如果想5、6。。插入，就会数组越界
Course cr3 = new Course("3","N语言");
this.coursesToSelect.add(4,cr3); //list数据添加不允许中间隔开，要紧挨着，这样会报越界
7.3.2 addAll:
//addAll 将对象批量添加到list
Course[] course = {new Course("4","离散数学"),new Course("5","汇编语言")};
this.coursesToSelect.addAll(Arrays.asList(course));
Course[] course2 = {new Course("5","语文"),new Course("6","数学")};
this.coursesToSelect.addAll(2,Arrays.asList(course)); //"5语文"在list的第2个位置,"6数学"在list第3个位置
7.3.3 site():获取list长度
7.3.4 get():从list中获取单个数据
7.3.4.1 普通遍历for
ListTest lt = new ListTest();
lt.testAdd(); //批量添加课程
List courseList = lt.coursesToSelect;
for(int i = 0 ;i<courseList.size();i++){
Course course = (Course)courseList.get(i);
System.out.println(course.id+" "+course.name);
}
7.3.4.2 迭代器iterator:
ListTest lt = new ListTest();
lt.testAdd();
Iterator iter = lt.coursesToSelect.iterator();
while(iter.hasNext()){
Course course = (Course)iter.next();
System.out.println(course.id + " "+course.name);
}
7.3.4.3 用foreach
ListTest lt = new ListTest();
lt.testAdd();
for(Object object :lt.coursesToSelect){
Course course = (Course)object;
System.out.println(course.id + " " + course.name);
}
7.3.5 set修改list中某个位置的对象
ListTest lt = new ListTest();
List l = lt.coursesToSelect;
l.set(3,new Course("8","跑步"))
7.3.6 remove 删除list中单个对象
ListTest lt = new ListTest();
lt.testAdd();//添加了4个课程
Course course = (Course)lt.coursesToSelect.get(2);
lt.coursesToSelect.remove(course); //删除一个课程
for(Object obj :lt.coursesToSelect){
Course cou = (Course)obj;
System.out.println(cou.id + " "+cou.name); //纸打印3个
}
7.3.7 removeAll 批量删除list中对象
ListTest lt = new ListTest();
lt.testAdd();//添加了4个课程
Course courses[] = {(Course)lt.coursesToSelect.get(0),(Course)lt.coursesToSelect.get(2)};
lt.coursesToSelect.removeAll(Arrays.asList(courses)); //删除两个课程
7.4 泛型 ：通过泛型限制向集合中添加的数据类型（比如list是添加课程对象的，加入字符串或者其他对象等都会在编译的时候报错），取出来直接用就行了，再也不需要再取出来去类型转换
7.4.1 定义：
public List<Course> courses; //<>即为泛型，此list只能添加course对象，添加其他就报错
7.4.2 取出来不需要转换(以foreach为例)：
ListTest lt = new ListTest();
lt.testAdd();
for(Course course :lt.coursesToSelect){
System.out.println(course.id + " " + course.name);
}
7.4.3 泛型集合(connection、map)中不仅可以存放泛型类型对象，也可以存放泛型类型的子类对象：
如 List<Course> 的List不仅可以存Course的对象，也可以存Course子类对象
7.4.4 泛型不能使用基本数据类型，必须用包装类替换基本数据类型：
【错误】：List<int> list = new ArrayList<int>();
【正确】：List<Integer> list = new ArrayList<Integer>();
7.5 set集：无序不可重复
7.5.1 与list一样存在 add()、addAll()、size()、remove()、removeAll()方法
7.5.2 与list不一样的是不存在set()、get()修改元素获取元素，因为set是无序的，无法知道在哪个位置是哪个元素
7.5.3 set只能通过循环或者迭代获取内容，不能通过get获取
7.5.4 set可以添加null，但是一般对业务没有实际用途
7.6 map：key-value 映射关系
put(key,value):
remove(key):
put、ketSet(返回所有键的集合)、remove、entrySet(返回map中所有键值对的集合)例子：
public class MapTest {
public Map<String,Student> students;
public MapTest(){
this.students = new HashMap<String,Student>();
}
/**
* map put(添加)
*/
public void testPut(){
Scanner console = new Scanner(System.in);
int i = 0;
while(i<3){
System.out.println("请输入学生id：");
String ID = console.next();
Student st = this.students.get(ID);
if(st == null){
System.out.println("请输入姓名");
String Name = console.next();
Student newst = new Student(ID,Name);
this.students.put(ID, newst);
System.out.println("成功添加用户用户："+Name);
i++;
}else{
System.out.println("该用户已存在");
continue;
}
}
}
/**
* map ketSet
*/
public void testKeySet(){
//通过keyset方法,返回map中所有“键”的set集合
Set<String> ketSet = this.students.keySet();
//便利set获取到每一个“键”，在调用map的get方法传入键值，就可以获取到map中该“键”对应的value
System.out.println("总共有："+this.students.size()+"个学生");
for(String ID : ketSet){
Student student = this.students.get(ID);
if(student != null){
System.out.println("学生："+student.name);
}
}
}
/**
* map remove
*/
public void testRemove(){
Scanner console = new Scanner(System.in);
while(true){
System.out.println("请输入要删除学生的ID");
String ID = console.next();
Student st = this.students.get(ID);
if(st == null){
System.out.println("ID不存在");
continue;
}else{
this.students.remove(ID);
System.out.println("删除成功:"+ st.name);
break;
}
}
}
/**
* map entrySet
*/
public void testEntrySet(){
//通过keyset方法,返回map中所有“键”的set集合
Set<Entry<String,Student>> entrySet = this.students.entrySet();
for(Entry<String,Student> entry : entrySet){
System.out.println("取得键:"+entry.getKey());
System.out.println("取得对应的值:"+entry.getValue().name);
}
}
/**
* map put(修改)
*/
public void testModify(){
Scanner console = new Scanner(System.in);
while(true){
System.out.println("请输入要修改姓名学生的ID");
String ID = console.next();
Student st = this.students.get(ID);
if(st == null){
System.out.println("ID不存在");
continue;
}
System.out.println("当前学生姓名为:"+ st.name + "请输入新的姓名");
String NEWNAME = console.next();
Student newst = new Student(ID,NEWNAME);
this.students.put(ID, newst);
System.out.println("修改成功");
break;
}
}
}
主类：
public static void main(String[] args){
MapTest mt = new MapTest();
//add
mt.testPut();
mt.testKeySet();
//remove
// mt.testRemove();
// mt.testEntrySet();
//update
mt.testModify();
mt.testEntrySet();
}
7.7 contains、containsAll(与addAll、removeAll用法一样)：SET、LIST是否包含某个对象
7.7.1 :LIST中是否包含某个对象
7.7.1.1 ：判断对象是否存在SET、LIST
/**
* 测试List contains方法
*/
public void testListContains(){
Course course = this.coursesToSelect.get(0);
System.out.println("取得课程："+course.name);
System.out.println("备选课程中是否包含课程：："+course.name+","+this.coursesToSelect.contains(course)); //True
}
7.7.1.2 ：判断对象中某个属性是否一样从而判断对象是否相等，重写equals方法 ，实际上contains也是一个个去比较equals方法
如：Course中有id、name，默认是id，name都相同才认为相同，但是现在我想只要课程name相同就算存在，那equals重写如下,排除id比较：
public class Course {
public String id;
public String name;
public Course(String id,String name){
this.id = id;
this.name = name;
}
@Override
public boolean equals(Object obj) {
if (this == obj)
return true;
if (obj == null)
return false;
if (getClass() != obj.getClass())
return false;
Course other = (Course) obj;
if (name == null) {
if (other.name != null)
return false;
} else if (!name.equals(other.name))
return false;
return true;
}
}
//调用
public class SetTest {
public List<Course> coursesToSelect;
public SetTest(){
this.coursesToSelect = new ArrayList();
}
public void testListContains(){
Course[] course = {new Course("3","离散数学"),new Course("4","汇编语言")};
this.coursesToSelect.addAll(Arrays.asList(course));
Course course =new Course("4","离散数学");
System.out.println("备选课程中是否包含课程：："+course.name+","+this.coursesToSelect.contains(course)); //true
}
}
7.7.2 :SET中是否包含某个对象
7.7.2.1 SET写法与LIST相同，当你输入一个SET中存在的一个name时候，会返回false，由于Set是通过HashSet实例化的，HashSet会执行hashcode方法，
SET在调用contains时候，不止回去对比equals，在调用equals对比之前，先去调了hashcode，所以这里不仅用重写equals，也要重写hashcode
重写代码如下：
@Override
public int hashCode() {
final int prime = 31;
int result = 1;
result = prime * result + ((name == null) ? 0 : name.hashCode());
return result;
}
@Override
public boolean equals(Object obj) {
if (this == obj)
return true;
if (obj == null)
return false;
if (getClass() != obj.getClass())
return false;
Course other = (Course) obj;
if (name == null) {
if (other.name != null)
return false;
} else if (!name.equals(other.name))
return false;
return true;
}
//我们只对比name属性，重写了hashcode与equals之后，通过SET在去调用contains对比，如果name存在就不会再返回false了,具体代码参考LIST中，只需要把LIST换成SET
7.7 indexOf：返回对象在LIST中的第一次出现的索引位置,原理跟contains差不多，也是循环比较每个对象中的equals方法，如果为true返回第一次出现的索引位置
list.indexOf(obj)
lasatIndexOf: 返回对象在LIST中的最后一次出现的索引位置
list.lasatIndexOf(obj)
【注意】：如果都没找到，返回-1 ，其实用法跟字符串的indexOf、lastIndexOf一样
7.8 map中是否包含key、value：
7.8.1 map.containsKey(key) // 判断key是否存在于map的key中
7.8.2 map.contaimsValue(param) //判断param是否存在于map的value中，contaimsValue与LIST、SET一样，如果param是对象，就会去调用里面的equals对比，所以重写equals
7.9 Comparable、Comparator
7.10.1 Comparable接口：可比较的，实现该接口的类的实例可以比较大小，可以进行自然排序，定义了默认比较规则，其实现类需实现compareTo方法，
compareTo返回正数表示大，负数表示小，0表示相等
7.10.2 Comparator接口：比较工具接口，用于定义临时比较规则，而不是默认比较规则，其实现类必须实现compare方法,Comparable与Comparator都是Java集合框架的成员。
【注】：所有java集合包含：Collection接口、Map接口、Collections工具类、Comparable接口、Comparator接口
7.10 sort(Collections下的方法)：给LIST排序
7.10.1 给数字、字符串排序：
public class CollectionsTest {
public void testSort1(){
List<Integer> integerList = new ArrayList<Integer>();
Random random = new Random();
Integer k;
for(int i=0;i<10;i++){
do{
k = random.nextInt(100); //生成100以内的随机数
}while(integerList.contains(k));
integerList.add(k);
System.out.println("成功添加整数："+k);
}
System.out.println("排序前");
for(Integer inte : integerList){
System.out.println("元素："+inte);
}
//排序
Collections.sort(integerList);
System.out.println("排序后");
for(Integer inte : integerList){
System.out.println("元素："+inte);
}
}
public static void main(String[] args){
CollectionsTest c =new CollectionsTest();
c.testSort1();
}
}
7.10.2 给对象排序：想要使用这个sort排序的对象，它的类必须要实现comparable接口或者comparator接口：
7.10.2.1 ：实现comparable
public class Student implements Comparable<Student>{
public String id;
public String name;
public Set<Course> courses;
public Student(String id,String name){
this.id = id;
this.name = name;
this.courses = new HashSet<Course>();
}
@Override //必须要实现
public int compareTo(Student o) {
// TODO Auto-generated method stub
return this.id.compareTo(o.id); //只比较id大小
}
}
//主类调用
public void testSort1(){
List<Student> strList = new ArrayList<Student>();
Random r = new Random();
Student s1 = new Student(String.valueOf(r.nextInt(1000)),"ming");
Student s2 = new Student(String.valueOf(r.nextInt(1000)),"hong");
Student s3 = new Student(String.valueOf(r.nextInt(1000)),"xiao");
Student s4 = new Student(String.valueOf(r.nextInt(1000)),"ha");
strList.add(s1);
strList.add(s2);
strList.add(s3);
strList.add(s4);
System.out.println("排序前");
for(Student inte : strList){
System.out.println(inte.id + " " + inte.name);
}
//排序
Collections.sort(strList);
System.out.println("排序后");
for(Student inte : strList){
System.out.println(inte.id + " " + inte.name);
}
}
【注】：id是字符串，他不会按照数字比较，他会比较第一位数字
7.10.2.2 :实现comparator
Student类：
public class Student{
public String id;
public String name;
public Set<Course> courses;
public Student(String id,String name){
this.id = id;
this.name = name;
this.courses = new HashSet<Course>();
}
}
Comparator定义临时排序类，根据姓名排序
public class StudentComparator implements Comparator<Student>{
@Override
public int compare(Student o1, Student o2) {
// TODO Auto-generated method stub
return o1.name.compareTo(o2.name);
}
}
//对比排序
public void testSort1(){
List<Student> strList = new ArrayList<Student>();
Random r = new Random();
Student s1 = new Student(String.valueOf(r.nextInt(1000)),"ming");
Student s2 = new Student(String.valueOf(r.nextInt(1000)),"hong");
Student s3 = new Student(String.valueOf(r.nextInt(1000)),"xiao");
Student s4 = new Student(String.valueOf(r.nextInt(1000)),"ha");
strList.add(s1);
strList.add(s2);
strList.add(s3);
strList.add(s4);
System.out.println("排序前");
for(Student inte : strList){
System.out.println(inte.id + " " + inte.name);
}
Collections.sort(strList,new StudentComparator());
System.out.println("排序后");
for(Student inte : strList){
System.out.println(inte.id + " " + inte.name);
}
}
