标签：
静态导入：import static 包名.类名.静态属性|静态方法|*
自动装箱/拆箱：
自动装箱：可以把一个基本数据类型直接赋给对应的包装类
eg：Integer i = 1 //装箱 实际为 Integer i = new Integer(1); 自动把1封装成一个Integer对象
自动拆箱：可以把一个包装类对象直接赋给对应的基本数据类型
eg：Integer i = 1;int j = i //拆箱
运用：
Integer i = 1;
int j = i;
1 List list = new ArrayList(); 2 list.add(1); //可以添加任何对象。 3 list.add(3); 4 list.add(2); 5 Iterator it = list.iterator(); 6 while(it.hasNext()){ //遍历 7 int k = (Integer) it.next(); 8 }
增强for循环：取数组和集合的数据---只适合取数据。只能用在数组，或实现iterable接口的集合上
语法格式：for(变量类型 变量 ：需迭代的数组或集合){}
package cn.lcp.eclipse; import java.util.ArrayList; import java.util.HashMap; import java.util.Iterator; import java.util.LinkedHashMap; import java.util.List; import java.util.Map; import java.util.Map.Entry; import java.util.Set; import org.junit.Test; public class Demo3 { /* *1 *2 *3 */ @Test public void test(){ int arr[] = {1, 2, 3}; for(int num : arr){ System.out.println(num); } }
/* *1 *2 *3 */ @Test public void test2(){ List list = new ArrayList(); list.add(1); list.add(2); list.add(3); for(Object obj : list){ int i = (Integer) obj; System.out.println(i); } }
@Test public void test3(){ Map map = new HashMap(); map.put("1", "aaa"); map.put("2", "bbb"); map.put("3", "ccc"); //传统方式1 /* * 3=ccc * 2=bbb * 1=aaa */ Set set = map.keySet(); //得到一个set集合，保存了map里面的所有的key Iterator it = set.iterator(); //通过迭代器取到所有的key while(it.hasNext()){ String key = (String) it.next(); //把取到的的key强转成字符串 String value = (String) map.get(key); //得到key所对应的值 System.out.println(key + "=" + value); } } @Test public void test3_2(){ Map map = new LinkedHashMap(); map.put("1", "aaa"); map.put("2", "bbb"); map.put("3", "ccc"); //传统方式2 /* * 1=aaa * 2=bbb * 3=ccc */ Set set = map.keySet(); //得到一个set集合，保存了map里面的所有的key Iterator it = set.iterator(); //通过迭代器取到所有的key while(it.hasNext()){ String key = (String) it.next(); //把取到的的key强转成字符串 String value = (String) map.get(key); //得到key所对应的值 System.out.println(key + "=" + value); } } /* *1=aaa *2=bbb *3=ccc */ @Test public void test4(){ Map map = new LinkedHashMap(); map.put("1", "aaa"); map.put("2", "bbb"); map.put("3", "ccc"); //传统方式3 Set set = map.entrySet(); //里面存放的都是一个个键值对 Iterator it = set.iterator(); //通过迭代器取到所有的key，和value while(it.hasNext()){ Map.Entry entry = (Entry) it.next(); //获取的是一个Map.Entry String key = (String) entry.getKey(); //得到key String value = (String) entry.getValue(); //得到value System.out.println(key + "=" + value); } } /* *1=aaa *2=bbb *3=ccc */ @Test public void test5(){ Map map = new LinkedHashMap(); map.put("1", "aaa"); map.put("2", "bbb"); map.put("3", "ccc"); //增强for循环1 /* * 因为map集合不能直接迭代，所以先把map集合转成set集合 */ for(Object obj : map.keySet()){ //先把map集合转成set集合，每个obj都是一个key String key = (String) obj; String value = (String) map.get(key); //拿到key所对应的值 System.out.println(key + "=" + value); } } /* *1=aaa *2=bbb *3=ccc */ @Test public void test6(){ Map map = new LinkedHashMap(); map.put("1", "aaa"); map.put("2", "bbb"); map.put("3", "ccc"); //增强for循环2 /* * 因为map集合不能直接迭代，所以先把map集合转成set集合 */ for(Object obj : map.entrySet()){ //每一个obj都是一个object的键值对 Map.Entry entry = (Entry) obj; //把obj转化成entry，获取的是一个Map.Entry String key = (String) entry.getKey(); //得到key String value = (String) entry.getValue(); //得到value System.out.println(key + "=" + value); } } @Test public void test7(){ //增强for循环 /* * 注意事项:只适合取数据 * 1 * 2 * 3 */ int arr[] = {1, 2, 3}; for(int i : arr){ i = 10; } //只能通过传统的方式改变数组里面的值。 for(int i = 0; i < arr.length; i ++){ arr[i] = 10; } System.out.println(arr[0]); System.out.println(arr[1]); System.out.println(arr[2]); List list = new ArrayList(); list.add("1"); for(Object obj : list){ obj = "10"; //定义变量有原来指向1，现在指向10.并没有改变集合里面的东西 } System.out.println(list.get(0)); } }
可变参数：
package cn.lcp.eclipse; import java.util.ArrayList; import java.util.Arrays; import java.util.List; import org.junit.Test; public class Demo4 { //可变参数 @Test public void testSum(){ //这两种调法都是一样的结果 1）sum(1, 2, 3, 4, 5, 8); 2）int arr[] = {1, 2, 3, 4, 5, 8}; sum(arr); } public void sum(int ...num){ //可变参数可以把它看成一个数组 int sum = 0; for(int i : num){ sum += i; } System.out.println(sum); } //可变参数注意事项：public void sum(int ...num, int i)这样错误 //public void sum(int i, int ...num)这样可以 @Test //asList参数是一个或多个对象，即为可变对象。 public void bb(){ List list = Arrays.asList("1", "2", "3"); //""是一个对象 System.out.println(list); String arr[] = {"1","2","3","5"}; list = Arrays.asList(arr); System.out.println(list); int nums[] ={1, 2, 4}; list = Arrays.asList(nums); //把数组当成一个对象往里面放 System.out.println(list); Integer nums_2[] ={1, 2, 4}; //对象数组 list = Arrays.asList(nums_2); //把对象数组往里面放 System.out.println(list); /* * [1, 2, 3] * [1, 2, 3, 5] * [[I@3cb243d7] * [1, 2, 4] */ } }
枚举值：
作用：程序运行时，需要的数据不能是任意的，而必须是一定范围内的值，可以直接采用枚举解决
用enum关键字定义一个枚举类。
一个枚举可以有构造函数，字段和方法。
是一样的效果。
class Grade{
public static final Grade A = new Grade();
}
enum Grade{ //相当于一个类
A, B, C, D; //是一个Object，这里的A是通过调用无参构造函数public static final Grade A = new Grade();
}
package cn.lcp.enumeration; import org.junit.Test; public class Demo { @Test public void test(){ print(Grade.B); } public void print(Grade g){ String value = g.getValue(); System.out.println(value); } } enum Grade{ //相当于一个类 A("100-90"), B("89-80"), C("79-70"), D("69-0"); //是一个Object private String value; //封装每个对象对应的分数 private Grade(String value){ //定义枚举的构造函数，字段，方法 this.value = value; } public String getValue(){ return this.value; } }
带抽象方法的枚举：
枚举常用方法：
枚举类特征：枚举类是一个特殊的java类/声明的每一个枚举值代表枚举类的一个实例对象/声明枚举类时，可以声明属性，方法和构造函数，但构造函数必须为私有的。
枚举类也可以实现接口，或继承抽象类/switch语句可以接受一个枚举类型/若枚举类只有一个值，则可以作为单态设计模式使用
java中声明的枚举类，均是java.lang.Enum类的孩子，它继承了Enum类的所有方法。
常用name()-返回枚举的常量名称; ordinal()-返回当前枚举值在枚举中的位置，校表从0开始;
valueof(class enumname, String name)-将某个字符串转成枚举;value()-遍历枚举的所有的值;
package cn.lcp.enumeration; import org.junit.Test; public class Demo2 { @Test public void test(){ print(G.B); } public void print(G g){ String value = g.localValue(); System.out.println(value); } public void test2(){ System.out.println(G.A.name());//得到C的枚举类名称 System.out.println(G.A.name());//得到枚举的位置，下标从0开始 String str = "B"; //把字符串转化成枚举,在实际开发中，需要将表单中的值改变为枚举值 G g = G.valueOf(G.class, str); G g_2 = G.valueOf(str); System.out.println(g); G[] g_3 = G.values(); //返回的是一个枚举类的数组，存储的是枚举值 for(G gg : g_3){ System.out.println(gg); } } } enum G{ //相当于一个类 A("100-90"){ //new出每一个对象，都要把这个枚举的抽象方法实现了 public String localValue(){ return "优"; } } , B("89-80"){ public String localValue(){ return "良"; } } , C("79-70"){ public String localValue(){ return "中"; } } , D("69-0"){ public String localValue(){ return "差"; } }; //是一个Object private String value; //封装每个对象对应的分数 private G(String value){ //定义枚举的构造函数，字段，方法 this.value = value; } public abstract String localValue(); }
public void test2(){ System.out.println(G.A.name());//得到C的枚举类名称 System.out.println(G.A.name());//得到枚举的位置，下标从0开始 String str = "B"; //把字符串转化成枚举,在实际开发中，需要将表单中的值改变为枚举值 G g = G.valueOf(G.class, str); G g_2 = G.valueOf(str); System.out.println(g); G[] g_3 = G.values(); //返回的是一个枚举类的数组，存储的是枚举值 for(G gg : g_3){ System.out.println(gg); } }
反射：反射就是加载类，并解剖出类的各个组成部分。一个类有多个组成部分，如：成员变量，成员方法，构造方法，是基于配置文件，是做框架的
加载类：Class类代表某一个类的字节码。
Class类代表某个类的字节码，提供加载某个类的字节码的方法：forName()--用于加载某个类的字节码到内存中，并使用class对象进行封装。
得到class对象的方法： 类名.class; 对象.getClass()
3种方法获取类的字节码文件
//1 这里已经有一个Person类了
Class class_1 = Class.forName("cn.lcp.reflect.Person");//把硬盘里面的字节码，加载到内存里面了。并使用class_1对象进行封装，所以就保存了这个类的字节码。
//2
Class class_2 = new Person().getClass();
//3
Class class_3 = Person.class;
解剖类：getConstructor,getMethod,getField,这是获取公共的构造函数，方法，成员变量（属性）。解剖出来的成员分别使用Constructor，Method，Field对象表示。
getDeclaredConstructor,getDeclaredMethod,getDeclaredField,这是获取私有的构造函数，方法，成员变量（属性）
利用Constructor创建对象：
//反射构造函数：public Person() @Test public void test1()throws Exception{ //获取Person类的字节码文件 Class clazz = Class.forName("cn.lcp.reflect.Person"); //反射的是一个public无参构造函数 Constructor c = clazz.getConstructor(null); //利用反射出的无参构造函数实例化一个Person对象 Person p = (Person) c.newInstance(null); //检测调用是否成功 System.out.println(p.name); } //反射构造函数：private Person(List list) @Test public void test2()throws Exception{ //获取Person类的字节码文件 Class clazz = Class.forName("cn.lcp.reflect.Person"); //反射的是一个private无参构造函数 Constructor c = clazz.getDeclaredConstructor(List.class); //利用反射出的无参构造函数实例化一个Person对象 //可以加上这句：c.setAccessible(true); //暴力反射， Person p = (Person) c.newInstance(new ArrayList()); //检测调用是否成功 System.out.println(p.name); } //创建构造函数的另外的一种方法，与test1相同 public void test4() throws Exception{ Class clazz = Class.forName("cn.lcp.reflect.Person"); Person p = (Person) clazz.newInstance(); //这里是实例化无参的构造函数 }
利用Method执行方法:
//反射类的方法 /*public void a1(){ System.out.println("a1"); }*/ @Test public void test1() throws Exception{ Person p = new Person(); Class clazz = Class.forName("cn.lcp.reflect.Person"); Method method = clazz.getMethod("a1", null); //确定反射的哪个方法，第一个是方法名，第二个为函数参数的个数。 method.invoke(p, null); //第一个为对象，第二个调用方法的参数 }
@Test /*public void a1(String name, int password){ System.out.println(name + ":" + password); }*/ public void test2() throws Exception{ Person p = new Person(); Class clazz = Class.forName("cn.lcp.reflect.Person"); Method method = clazz.getMethod("a1", String.class, int.class); //确定反射的哪个方法，第一个是方法名，第二个为函数参数的个数。 method.invoke(p, "lcp", 38); //第一个为对象，第二个调用方法的参数 } @Test /*public Class[] a1(String name, int[] password){ return new Class[]{String.class}; }*/ public void test3() throws Exception{ Person p = new Person(); Class clazz = Class.forName("cn.lcp.reflect.Person"); Method method = clazz.getMethod("a1", String.class, int[].class); //确定反射的哪个方法，第一个是方法名，第二个为函数参数的个数。 Class cs[] = (Class[]) method.invoke(p, "lcp", new int[]{1, 2, 3}); //第一个为对象，第二个调用方法的参数 System.out.println(cs[0]); //因为那个方法返回一个值。 } @Test /*private void a1(InputStream in){ System.out.println(in); }*/ public void test4() throws Exception{ Person p = new Person(); Class clazz = Class.forName("cn.lcp.reflect.Person"); Method method = clazz.getDeclaredMethod("a1", InputStream.class); //确定反射的哪个方法，第一个是方法名，第二个为函数参数的个数。 method.setAccessible(true); //强制打开访问权限 method.invoke(p, new FileInputStream("C:\\1.txt")); //第一个为对象，第二个调用方法的参数 } @Test /*public static void a1(int num){ System.out.println(num); }*/ public void test5() throws Exception{ Class clazz = Class.forName("cn.lcp.reflect.Person"); Method method = clazz.getMethod("a1", int.class); //确定反射的哪个方法，第一个是方法名，第二个为函数参数的个数。 method.invoke(null, 23); //第一个为对象，第二个调用方法的参数,静态方法调用时不需要对象 }
反射main方法：
@Test /*public static void main(String[] args) { System.out.println("main"); }*/ public void test() throws Exception{ Class clazz = Class.forName("cn.lcp.reflect.Person"); Method method = clazz.getMethod("main", String[].class); //确定反射的哪个方法，第一个是方法名，第二个为函数参数的个数。 //method.invoke(null, (Object)new String[]{"aa", "bb"}); //第一个为对象，第二个调用方法的参数,静态方法调用时不需要对象 method.invoke(null, new Object[]{new String[]{"aa", "bb"}}); }
反射类的字段：
//反射字段 //public String name = "aaa"; @Test public void test1() throws Exception{ Person p = new Person(); Class clazz = Class.forName("cn.lcp.reflect.Person"); Field f = clazz.getField("name"); //确定某个字段名 Object value = f.get(p); //获取字段值 Class type = f.getType(); //获取字段的类型 if(type.equals(String.class)){ String svalue = (String) value; //把字段转换成String System.out.println(svalue); } f.set(p, "lop"); //设置某个对象的字段值 } //private int password = 123; @Test public void test2() throws Exception{ Person p = new Person(); Class clazz = Class.forName("cn.lcp.reflect.Person"); Field f = clazz.getDeclaredField("password"); //确定某个字段名 f.setAccessible(true); //强制打开访问权限 System.out.println(f.get(p)); //得到字段值 } //private static int age = 22; @Test public void test3() throws Exception{ Person p = new Person(); Class clazz = Class.forName("cn.lcp.reflect.Person"); Field f = clazz.getDeclaredField("age"); //确定某个字段名 f.setAccessible(true); //强制打开访问权限 System.out.println(f.get(p)); //得到字段值 }
内省操作javabean的属性：
public class Person { //javabean private String name; //字段 private String password; //字段 private int age; //属性1：ab public String getAb(){ return null; } //属性2：name public String getName(){ return name; } //属性2：name public void setName(String name){ this.name = name; } //属性3：password public String getPassword(){ return name; } //属性3：password public void setPassword(String password){ this.password = password; } //属性4：age public int getAge(){ return age; } public void setAge(int age){ this.age = age; } //属性5：class。因为任何类都是都是object的孩子。里面自动继承了Object的属性。里面有一个getClass方法。 }
package cn.lcp.introspector; import java.beans.BeanInfo; import java.beans.Introspector; import java.beans.PropertyDescriptor; import java.lang.reflect.Method; import org.junit.Test; public class Demo { @Test /** * 得到bean的所有属性 * @throws Exception */ public void test1() throws Exception{ //内省某个类，拿到类的所有属性--是某个set或get方法 //因为任何类都是都是object的孩子。里面自动继承了Object的属性。里面有一个getClass方法。 BeanInfo info = Introspector.getBeanInfo(Person.class); //得到bean自己的属性，出去从父类继承的属性 BeanInfo info2 = Introspector.getBeanInfo(Person.class, Object.class); //拿到属性描述器 PropertyDescriptor[] pds = info2.getPropertyDescriptors(); for(PropertyDescriptor pd : pds){ System.out.println(pd.getName()); } } /** * 操作bean的指定属性 * @throws Exception */ @Test public void test2() throws Exception{ Person p = new Person(); PropertyDescriptor pd = new PropertyDescriptor("age", Person.class); //使用指定的age属性 //相当于Person的public void setAge(int age)属性 //得到属性的写方法，为属性赋值 Method method = pd.getWriteMethod(); method.invoke(p, 44); //获取属性值 method = pd.getReadMethod(); //public int getAge(); System.out.println(method.invoke(p, null)); //getAge这个函数没有参数 } /** * 获取当前操作的属性类型 * @throws Exception */ @Test public void test3() throws Exception{ PropertyDescriptor pd = new PropertyDescriptor("age", Person.class); System.out.println(pd.getPropertyType()); } }
使用beanUtils操作javabean：需要commons-logging的jar包和 beanUtilsjar包。
在java文件与src相同等级新建一个lib文件夹，把两个jar包放到这个地方，选中这两个jar包，右击build path->add to build path
package cn.lcp.beanutils; import java.util.Date; public class Person { //javabean private String name; //字段 private String password; //字段 private int age; private Date birth; public String getName() { return name; } public void setName(String name) { this.name = name; } public String getPassword() { return password; } public void setPassword(String password) { this.password = password; } public int getAge() { return age; } public void setAge(int age) { this.age = age; } public Date getBirth() { return birth; } public void setBirth(Date birth) { this.birth = birth; } }
package cn.lcp.beanutils; import java.lang.reflect.InvocationTargetException; import java.text.ParseException; import java.text.SimpleDateFormat; import java.util.Date; import java.util.HashMap; import java.util.Map; import org.apache.commons.beanutils.BeanUtils; import org.apache.commons.beanutils.ConversionException; import org.apache.commons.beanutils.ConvertUtils; import org.apache.commons.beanutils.Converter; import org.apache.commons.beanutils.locale.converters.DateLocaleConverter; import org.junit.Test; //使用beanutils操纵bean属性 public class Demo { @Test public void test() throws IllegalAccessException, InvocationTargetException{ Person p = new Person(); BeanUtils.setProperty(p, "name", "xcc"); System.out.println(p.getName()); } @Test public void test2() throws IllegalAccessException, InvocationTargetException{ String name = "xxcc"; String password = "123"; String age = "11"; String birth = "1990-09-09"; Person p = new Person(); BeanUtils.setProperty(p, "name", name); //只支持8种基本数据类型 BeanUtils.setProperty(p, "password", password); BeanUtils.setProperty(p, "age", age); System.out.println(p.getName()); System.out.println(p.getPassword()); System.out.println(p.getAge()); } @Test public void test3() throws IllegalAccessException, InvocationTargetException{ String birth = "1990-09-09"; //为了让日期赋值到bean的birth属性上，我们给beanUtils注册一个日期转换器。 ConvertUtils.register(new Converter(){ public Object convert(Class type, Object value){ if(value == null){ return null; } if(!(value instanceof String)){ throw new ConversionException("只支持String类型的转换"); } String str = (String) value; if(str.trim().equals("")){ return null; } //设置日期格式 SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd"); try { return df.parse(str); } catch (ParseException e) { // TODO Auto-generated catch block throw new RuntimeException(e); //异常链不能断 } } }, Date.class); Person p = new Person(); BeanUtils.setProperty(p, "birth", birth); System.out.println(p.getBirth()); } @Test public void test4() throws IllegalAccessException, InvocationTargetException{ String birth = "1990-09-09"; //为了让日期赋值到bean的birth属性上，我们给beanUtils注册一个日期转换器。 //有bug ConvertUtils.register(new DateLocaleConverter(), Date.class); Person p = new Person(); BeanUtils.setProperty(p, "birth", birth); System.out.println(p.getBirth()); } @Test public void test5() throws IllegalAccessException, InvocationTargetException{ Map map = new HashMap(); map.put("name", "aa"); map.put("password", "123"); map.put("age", "23"); map.put("birth", "1980-09-09"); ConvertUtils.register(new DateLocaleConverter(), Date.class); Person bean = new Person(); BeanUtils.populate(bean, map); //把map集合中的值填充到bean的属性上 System.out.println(bean.getName()); System.out.println(bean.getPassword()); System.out.println(bean.getAge()); System.out.println(bean.getBirth()); } }
泛型：//前面定义变量指定一个集合，通过泛型<String>指定的集合处理类型必须是String类型
List<String> list1 = new ArrayList<String>();
list1.add("qqq");
String s = list1.get(0);
System.out.println(s);
@Test public void test(){ List<String> list = new ArrayList<String>(); list.add("aaa"); list.add("bbb"); list.add("ccc"); //集合迭代器 Iterator<String> it = list.iterator(); while(it.hasNext()){ String value = it.next(); System.out.println(value); } //增强for循环 for(String s : list){ System.out.println(s); } } @Test public void test2(){ //定义一个变量，指向一个map集合。指向一个map集合，关键字是Integer，值是String类型 Map<Integer, String> map = new LinkedHashMap(); map.put(1, "aa"); map.put(2, "bb"); map.put(3, "cc"); map.put(4, "dd"); //传统keyset，entryset Set<Map.Entry<Integer, String>> set = map.entrySet(); Iterator<Map.Entry<Integer, String>> it = set.iterator(); while(it.hasNext()){ Map.Entry<Integer, String> entry = it.next(); int key = entry.getKey(); String value = entry.getValue(); System.out.println(key + " : " + value); } //增强for循环<重点> for(Map.Entry<Integer, String> entry : map.entrySet()){ int key = entry.getKey(); String value = entry.getValue(); System.out.println(key + " : " + value); } }
自定义泛型：自定义泛型方法，自定义泛型类
自定义泛型方法：
@Test
//先声明T 再使用T。
public <T> void a(T t){
}
//设置3个泛型，在使用方法的时候为TKE赋予具体的类型
public <T, K, E> void a(T t, K k, E e){
}
//如果很多个方法都使用到同一泛型：那么可以将泛型声明在类上面。作用域就是整个类的范围。只作用在这个类的非静态成员上面
public class Demo3<T> {
public void a(T t){
}
public <K ,E> void a(T t, K k, E e){
}
public static <T> void c(T t){
}
}
例子： 编写一个泛型方法，实现指定位置上的数组元素的交换 public <T> void swap(T arr[], int post1, int post2){ T temp = arr[post1]; arr[post1] = arr[post2]; arr[post2] = temp; } 编写一个泛型方法，实现跌倒数组中的所有元素 public <T> void reverse(T arr[]){ int start = 0; int last = arr.length - 1; for(start; start <= last; start ++,last--){ T temp = arr[start]; arr[post1] = arr[last]; arr[last] = temp; } }
标签：
原文地址：http://www.cnblogs.com/lcpholdon/p/4338912.html
