JAVA学习

Pattern Matcher 正则表达式
java.util.regex
Pattern /d 数字 /D 非数字，/w * 0 个或多个 +1 个或多个。
^   $开头结尾
静态导入
import static java.lang.Math.PI;
import static java.lang.System.*;
                      TestStaticImport.java 编译时加上版本号。看旧版是否支持新特性
javac -source 1.4
wrapper classes 包装类
所有的包装类覆盖了 Object 的 equals(),hashCode() toString()方法
Integer 中有一个 toString(int i,int radix)返回用第二个参数指定基数表示的第一个参
数的字符串表示形式。进制转换
先自动向上转型 再找包装类型 。但包装类型 不会向上转型 因为它们是对象。
与 string 对象池类似，8 种基本类型 的包装类型 都有这样的特征，在池上拿对象，但
（－128，127）的 int 在池中找。大于了要重新创建新对象。
                       Integer c1 = 128;//自动封箱..大于 127 时要重新创建 对象
                                 Integer c2 = 128;
                                 System.out.println(c1==c2);//false
                                 System.out.println(c1.equals(c2));//true
包装类默认值为 null.
枚举：构造 方法必须是 private 所有的枚举值必须是枚举类型 的第一个语句
每个枚举值是当前枚举的一个实例或一个对象。调用默认构造 方法。
Enum Season{
SPRING(“spring”),SUMMER(“summer),AUTUMN(“autumn”),WINTER(“winter”);
             private String name;
             private Season(String name){
                       this.name = name;
             }
             public String toString(){ return name;}
}
在 switch 中用枚举要注意：
          Gender g3 = null;
                                switch(g){ //默认调用 g.ordinal()方法
                                            case MALE: sex = "男";break; //用枚举值
                                            case FEMALE:sex = "女";break;
                                }
几个常用的枚举方法：
       name() 返回此枚举常量的名称，在其枚举声明中对其进行声明。
String
    ordinal() 返回枚举常量的序数（它在枚举声明中的位置，其中初始常量序数为零）。
int
Season[] ss = Season.values();//values 返回所有枚举值的枚举数组。
for(int i=0;i<ss.length;i++){
System.out.println(ss[i].name()+" "+ss[i].ordinal()+" "+ss[i].toString());}
Season s3 = Enum.valueOf(Season.class,"WINTER");
System.out.println(s3.name());
System.out.println(s3.ordinal());
边边角：枚举类型 不能被 继承 是一个 final 类。也不能继承其它类。
          枚举类型的抽象方法由枚举值来实现。
神奇的 enum:
public class TestEnum3{
                     public static void main(String[] args){
                                Operator[] os = Operator.values();
                                for(int i=0;i<os.length;i++){
                                            Operator o = os[i];
                                            int a =o.calculate(4,2);
                                            System.out.println(o.name()+" "+o+" "+a);
                                }
                     }
}
enum Operator{
                     ADD("加"){
                                public int calculate(int a,int b){
                                            return a+b;
                                }
                     },
                     MINUS("减"){
                                public int calculate(int a,int b){
                                            return a-b;
                                }
               },
               MUTIPLY("乘"){
                          public int calculate(int a,int b){
                                    return a*b;
                                    }
               },
               DIVIDE("除"){
                          public int calculate(int a,int b){
                                    return a/b;
                          }
               };
               private String name;
               private Operator(String name){
                          this.name = name;
               }
               public abstract int calculate(int a,int b);
               public String toString(){
                          return name;
               }
}
内部类：在内部类里面可访问外部类的所有属性和方法。.class 为外部类名+$+内部类名
静态内部类：只能访问静态成员。
成员对象内部类：必须通过外部类实例对象 . new 内部类。In = outer.new Inner();
     外部类方法中 Inner in = (this.)new Inner( );
     (new Outerclass()).new Innerclass();
     Outerclass.this.member 访问内部类成员变量。
局部内部类:在方法内申明，生命周期是在方法里。
匿名内部类:在方法里 new 一个无名的内部类，常 new 接口的实现。
     1 创建内部类对象：Outer.Inner in = new Outer.Inner();
                          in.m();
     2 在外部类调用内部非静态类方法必须建对象来访问
静态内部类：
static class{}
只能访问外部类静态成员。有构造方法。
产生对象的方式：Outer.Inner in = new Outer.Inner();
成员内部类 class Inner{}可以访问外问类任何成员
局部内部类：定义在方法中，可以访问外部类任何成员，没有修饰符
（public,private，protected,static)访问局部变量时该变量必须声明为最终类型 final ,
只能在定义该类的该局部方法中产生对象。可以是抽象类。
生成类为：Outer$1+局部（或匿名）.class
匿名内部类无构造方法。可以 new 一个接口。实现接口回调
集合：List        有序可重复元素 Set 元素无序且不能重复。
            迭代器：通过其来遍历集合，解耦。
编译问题：注意：QueueTest.java 使用了未经检查或不安全的操作。
            注意：要了解详细信息，请使用 -Xlint:unchecked 重新编译。
语法检查版本要支持泛型 （1.5 以上）。
            javac -source 1.4 QueueTest.java
老师总结：
静态内部类：
static class Inner{}
只能访问外部类静态成员。
有构造方法
产生对象的方式。
Outer.Inner in = new Outer.Inner();
成员内部类：
class Inner{}
可以访问外部类任何成员。
有构造方法
产生对象的方式。
通过外部类对象产生内部类对象
Outer.Inner in = null;
Outer outer = new Outer();
in = outer.new Inner();
局部内部类：定义在方法中,没有修饰符。
可以访问外部类任何成员。有构造方法
产生对象的方式:只能在定义该类的方法中产生对象。
异常栈：Exception in thread "main" java.lang.ClassCastException: Student cannot be cast to
java.lang.Comparable
at java.util.Arrays.mergeSort(Arrays.java:1144)
at java.util.Arrays.sort(Arrays.java:1079)
at java.util.Collections.sort(Collections.java:117)
at TestListSort.main(TestListSort.java:25)
//定义比较的规则
/*
升序规则：
当前对象大于传入对象，返回正数
当前对象小于传入对象，返回负数
当前对象等于传入对象，返回0
*/
Comparable 可比较 int compareTo(Object o);
//自己写比较器
class MyComparator implements Comparator{
public int compare(Object o1,Object o2){
Student s1 = (Student)o1;
Student s2 = (Student)o2;
return s1.name.compareTo(s2.name);
}
}
Collections.sort(list,new MyComparator());
数组：查找快，增删慢
链表：增删快，查找慢。
LinkedList底层使用链表来实现，链表的特征：扩容方便，添加元素和删除元素效率高。但
循环遍历效率不如数组；
HashSet 添加元素规则，hashCode方法和equals 方法必须同步覆盖
覆盖原则：
1一定让equals相等的元素返回相同的hashCode( 保证冲突）
2尽量让equals不等的元素返回不同的hashCode（避免不必要冲突）
3尽量让hashCode散列 （提高效率）；使用属性的hashCode()方法。或进行^操作
Iterable接口，代表可迭代访问的，
Iterable it = c.itrerable()
while(it.hasNext()) it.next();
SortedSet接口 TreeSet可排序不重复。可实现Comparable接口int compareTo(Object)排序方
法 实现排序时，实现的compareTo方法和equals方法要一致
LinkedHashSet 有插入顺序不重复。
Queue 队列 先进先出。Add要抛异常 offer不用。 remove()抛。poll()不用。 为空时返回
空。 peek()查看不移除对象
PriorityQueue优先队列。 Implements Comparable的int compareTo(Object)方法
在 java 中指定排序规则的方式只有两种：
1、实现 java.util 包下的 Comparator 接口
2、实现 java.lang 包下的 Comparable 接口
Set的存放是不按顺序的。但LinkedHashSet除外
知识点复习：
clone()
重载clone()方法一般调用super.clone();
class Computer implements Cloneable{
private String name;
private int price;
public Computer(){}
public Computer(String name,int price){
this.name = name;
this.price = price;
}
public Object clone() throws CloneNotSupportedException{
// Computer c = new Computer();
// c.name = this.name;
// c.price = this.price;
// Object obj = c;
Object obj = super.clone();//浅克隆。一般使用这种方
法
return obj;
// return this;}}
不变模式：1.private 属性；
2.在构造方法中给属性赋值
（如果属性是引用类型 ，则要克隆一份后再赋值）
3.只提供 get 方法（如果返回的是引用类型 ，则要克隆一份后再返回）
Eclipse的使用
快捷键：
Alt + ? syso自动完成输出语句
Alt+/ 模板方法
Ctrl+1 错误提示纠正
Ctrl+Shift+o 自动导入包
左键 错误纠正
右键：Source添加方法
Ctrl+D 删除一行 Ctrl+alt+down 向上复制
Ctrl+/ 注释 ／取消注释
Jre lib 添加JDK源码包 src.zip
Map 键 值
/**
*遍历Map中所有的键值对
*/
public static void printAllValue(Map map){
//得到所有键的集合
Set set = map.keySet();
//遍历键并通过get获得值
Iterator it = set.iterator();
while(it.hasNext()){
Object obj = it.next();
System.out.println(obj+":"+map.get(obj));
}
}
方法二：//得到所有键值对的值
Set set = map.entrySet();
//遍历set集合
Iterator it = set.iterator();
while(it.hasNext()){
Entry entry =(Entry)it.next();
Object key = entry.getKey();
Object value = entry.getValue();
System.out.println(key+"->"+value);
}
/**
*遍历Map中所有的值
*/
//得到所有value的集合
Collection c = map.values();
//遍历Collection集合
Iterator it = c.iterator();
while(it.hasNext()){
Object s = (具体类型) it.next();
System.out.println(s);
}
public int hashCode(){
System.out.println("XXXX");
return new Integer(age).hashCode()
+Double(salary).hashCode();
｝hashCode 使用包装类
HashSet的实现使用HashMap
HashMap允许null值
Properties prop = new Properties();
//读db.config文件。 文件＃注释掉
InputStream in = new FileInputStream("db.config");
prop.load(in);
System.
public static Properties getProperties()获得系统属性
for each
List arr = new ArrayList();
for(Object obj : arr){
}
<=> for(Iterator it = arr.iterator() ; it.hasNext() ; ){
Object obj= it.next();
}
for each 循环 任何一个类如果实现了Iterable接口就可使用for each
泛型 是一个编译型 类型 使用泛型与不使用编译后的字节码是一样的
使用了泛型 将不用进行强制类型 转换。
泛型 没有多态
泛型 方法
static<T> void copyOf(List<T> desc,T[] src){ }
static<T> void copyOf(List<? super T> desc,T[] src){}
static<T> void copyOf(List<? extends T> desc,T[] src){}
static<T> void copyOf(List<? extends Object> desc,T[] src){}
static<T> void copyOf(List<?> desc,T[] src){}
上界通配符使用extends关键字声明 ，表示参数化的类型可能是所指定的类型，或是其类
型的子类。当使用extends时，编译器不允许调用此对象的add，addAll,set等方法，但可以
使用for each或get.
下界通配符使用super关键字声明 ，表示参数化的类型可能是所指字的类型 ，或是其父
类型 直至Object.当一个集合对象使用＜？ Super XXX>声明时，编译器不允许调用此对象的
get方法，也不允许使用for each。但可以使用add,addAll.set等方法
老师总结：泛型add,get原则：
？Super T:
只能向集合中添加元素。add,addAll();
不能调用get，除非调用get方法给Object类型赋值
? extends T:
只能调用集合的get方法。
不能调用集合的add方法。
定义泛型不能向上限制
extends可以表示实现接口 但接口放后面。父类放前面
实现接口用ectends,接口写在类之后用 & 分隔
static <T extends Number & Comparable,Clonable> void print(List<T> list)
//静态泛型 方法不能使用泛型类中的类型
子类要保留父类的泛型 必须在子类中声明 父类泛型
子类有泛型 也要在类名后面声明 用 , 分开
定义泛型 类： class 类名 <U>
定义泛型方法：访问修饰符staitc<T> 返回类型 方法名（参数列表）｛方法体｝
使用泛型 类：类名<类型> 变量＝ new 类名<类型>
作用泛型 方法：类名.<类型> 方法名 (实参);
未检查异常：
RuntimeException 和其子类 可处理可不处理。
java.lang.ArithmeticException java.lang.ArrayIndexOutOfBoundsException
NullPointerException ClassCastException
已检查异常：
非RuntimeException和其子类
必须要处理
FileNotFoundException
处理：抛出去：throws
try{
FileInputStream in = new FileInputStream("a.txt");
}catch(FileNotFoundException ioe){
System.out.println(ioe.getMessage());//打印异常信息
ioe.printStackTrace();//打印异常栈，开发时用
}catch(EOFException e){
System.out.println(e.getMessage());
e.printStackTrace();
}catch(IOException e){
System.out.println(e.getMessage());
e.printStackTrace();
}finally{
}
只能先处理子异常，再处理父异常
1：throw new Exception() 产生异常 异常让用户处理
2：方法 throws 抛出异常
3：处理异常：1：throws 消极
2: try catch 积极 只执行一个catch代码块，
getMessage();
printStackTrace();
getCause();
assert 断言 返回false 时。马上终止虚拟机
java -ea TestAssert 开启断言
反射 类的类：类对象的模板
类对象：描述其他类的对象
1.对象.getClass();
2.类名.class
3.Class.forName(“类的全限定名”); ClassNotFoundException