Collection集合框架 反射
Collection接口
无序可重复 只能储存引用类型
-
增: add(Object)添加元素 返回是否成功添加true/false
addAll(coll)添加一个集合
-
删：clear()清空所有元素
remove(Object)移除一个
removeAll(coll)移除交集
retainAll(coll)只保留交集
改：没有修改元素
-
查：isEmpty()集合是否为空
size()集合元素的个数
contains(Object)集合中是否存在某个对象
containsAll(coll)集合中是否存在某个集合
public class Test01 {
public static void main(String[] args) {
//学习Collection接口中的方法 接口指向实现类对象
Collection coll = new ArrayList();
//添加元素 自动类型转换
coll.add("java");
coll.add(1);
System.out.println(coll);
Collection coll1 = new ArrayList();
coll1.add("python");
coll1.add("html");
coll.addAll(coll1);
System.out.println(coll);
//删除元素
//coll.clear(); 清空所有元素
//System.out.println(coll.remove(1)+"=="+coll); //移除一个指定值
//System.out.println(coll.removeAll(coll1)+"=="+coll); //移除交集
//System.out.println(coll.retainAll(coll1)+"=="+coll); //只保留交集
//查看元素
System.out.println("是否为空值 :"+coll.isEmpty());
System.out.println("查看当前集合元素的个数 :"+coll.size());
System.out.println("查看当前集合是否存在java :"+coll.contains("java"));
System.out.println("查看当前集合是否存在集合coll1 :"+coll.containsAll(coll1));
}
}
迭代
public class Test02 {
public static void main(String[] args) {
//创建集合对象
Collection coll = new ArrayList();
//添加元素
coll.add("String");
coll.add("1");
coll.add("Integer");
coll.add("Scanner");
System.out.println("集合为 ："+coll);
//迭代元素
System.out.println("foreach循环迭代");
for(Object obj:coll) {
String str = (String) obj;
System.out.println(str);
}
System.out.println("iterator迭代器");
Iterator it = coll.iterator();
while(it.hasNext()) {
System.out.println(it.next());
}
System.out.println("迭代器的变种写法");
for(Iterator it1 = coll.iterator();it1.hasNext();) {
System.out.println(it1.next());
}
}
}
List接口
有序 可重复 可以是null值 继承于Collection
相比Collection多了一些关于索引的方法
public class Test03 {
public static void main(String[] args) {
//创建对象
List ls = new ArrayList();
//添加元素
ls.add("java");
ls.add("python");
ls.add(0, "java01");
ls.add(2, "python02");
System.out.println(ls);
//删除元素
ls.remove(1);
System.out.println(ls);
//修改元素
ls.set(1, "html");
System.out.println(ls);
//查询元素
System.out.println("是否为null判定："+ls.isEmpty());
System.out.println("查看指定位置上的元素："+ls.get(0));
System.out.println(ls);
List newLs = ls.subList(1, 2); //从索引1-2元素 左闭右开
System.out.println(newLs);
ls.add("html");
System.out.println("查询指定元素的索引："+ls.indexOf("html"));
System.out.println("查询指定元素的索引(最后一次)："+ls.lastIndexOf("html"));
System.out.println("查询元素个数："+ls.size());
}
}
迭代
public class Test04 {
public static void main(String[] args) {
//创建对象
List ls = new ArrayList();
ls.add("小炮=崔丝塔娜");
ls.add("大嘴=克格莫");
ls.add("滑板鞋=卡利斯塔");
ls.add("老鼠=图奇");
System.out.println(ls);
//迭代
System.out.println("普通for循环======");
for(int i=0; iSet接口
无序 唯一 继承于Collection
public class Test01 {
public static void main(String[] args) {
// Set
Set sets = new HashSet<>();
//添加
sets.add("格莱美");
sets.add("奥斯卡");
sets.add("图灵奖");
System.out.println(sets.add("图灵奖"));
System.out.println(sets);
System.out.println("迭代元素");
for(String str:sets) {
System.out.println(str);
}
System.out.println("迭代元素 迭代器");
Iterator it = sets.iterator();
while(it.hasNext()) {
System.out.println(it.next());
}
}
}
ArrayList类
底层： 数组
优缺点分析：通过索引获取元素以及迭代元素比较快 但是添加、删除很慢
继承于List
查看当前是否存在大嘴 克格莫 如果存在则添加元素 ez 伊泽瑞尔 只能通过for循环/ListIterator(内置add()方法)完成
增强for以及iterator都会报异常 java.util.ConcurrentModificationException 并发修改异常
public class Test05 {
public static void main(String[] args) {
//创建对象
List ls = new ArrayList();
ls.add("小炮 崔丝塔娜");
ls.add("大嘴 克格莫");
ls.add("滑板鞋 卡利斯塔");
ls.add("老鼠 biubiubiu");
// 查看当前是否存在大嘴 克格莫 如果存在则添加元素 ez 伊泽瑞尔
System.out.println("普通for循环");
for(int i = 0;i正序迭代和逆序迭代
public class Test06 {
public static void main(String[] args) {
List ls = new ArrayList();
ls.add("小炮 崔丝塔娜");
ls.add("大嘴 克格莫");
ls.add("滑板鞋 卡利斯塔");
ls.add("老鼠 biubiubiu");
System.out.println("正序迭代");
ListIterator it = ls.listIterator();
while(it.hasNext()) {
System.out.println(it.next());
}
System.out.println("逆序迭代");
while(it.hasPrevious()) {
System.out.println(it.previous());
}
}
}
LinkedList类
底层： 双向链表
优缺点: 添加、删除快 获取元素慢
继承于List
LinkedList: 多了一些头尾的操作
public class Test09 {
public static void main(String[] args) {
//1: 创建对象
LinkedList ls = new LinkedList<>();
//2:添加元素
ls.add("不知火舞");
System.out.println(ls.get(0));
System.out.println(ls);
ls.add("橘右京");
ls.add("娜可露露");
ls.add("宫本武藏");
// 多了一些针对于头尾元素的操作
ls.addFirst("草薙京");
ls.addLast("八神庵");
System.out.println(ls.offer("春丽"));//添加到末尾
System.out.println(ls.offerFirst("春丽"));//添加到末尾
System.out.println(ls.offerLast("春丽"));//添加到末尾
System.out.println(ls);
System.out.println(ls.element());//获取头元素
System.out.println(ls.getFirst());
System.out.println(ls.getLast());
System.out.println(ls);
//ls = null;
System.out.println(ls.peekFirst());
System.out.println(ls.peek());
}
}
HashSet类
底层： 数组+链表 ?
优缺点：添加、删除、修改效率都很高
继承于Set
注意事项：hashset存储自定义对象时一定要重写hashcode和equals方法。
public class Test02 {
public static void main(String[] args) {
//创建一个HashSet
HashSet ss = new HashSet<>();
//添加User对象
ss.add(new User(6300,"疾风剑豪"));
ss.add(new User(4800,"雷霆咆哮"));
ss.add(new User(6300,"疾风剑豪"));
System.out.println(ss);
}
}
class User{
private int money;
private String name;
public User() {
// TODO Auto-generated constructor stub
}
public User(int money, String name) {
super();
this.money = money;
this.name = name;
}
public int getMoney() {
return money;
}
public void setMoney(int money) {
this.money = money;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
@Override
public String toString() {
return "User [money=" + money + ", name=" + name + "]";
}
@Override
public int hashCode() {
final int prime = 31;
int result = 1;
result = prime * result + money;
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;
User other = (User) obj;
if (money != other.money)
return false;
if (name == null) {
if (other.name != null)
return false;
} else if (!name.equals(other.name))
return false;
return true;
}
}
迭代器
迭代器：
- Iterable 是java.lang包下的接口 实现改接口都能够作为foreach的目标
- Iterator 是java.util包下的接口 迭代器 用来迭代当前集合对象的
- Iterator 是一个接口 ArrayList中通过内部类完成了对于改接口的实现 获取的其实是实现类对象
泛型
泛型：jdk1.5之后的新特性
数据类型
1：什么是泛型?
广泛的类型 也是一种数据类型 而这种数据类型可以是任意类型 编写过程当中不能确定该类型
创建对象时可以指定泛型的具体类型
2：
泛型是编译期行为，只能在编译器有效如果能够跨过编译期 那么泛型就没有任何意义
泛型类
如何定义泛型类
在类后加<> 括号中编写任意长度任意字符 不能是数值
一般情况下我们通过大写的26个字母去声明当前泛型 T type E element
使用：
jdk1.7之后支持泛型的类型推断
泛型类<具体类型> 变量名 = new 泛型类<>(); 泛型接口
实现类实现泛型接口时不指定泛型类型 此时创建实现类对象是可以指定泛型类型
class UserServiceImplimplements UserService
实现类实现泛型接口时指定泛型类型 那么将确定泛型类型
class UserServiceImpl implements UserService
泛型方法
方法中使用泛型 该方法就是一个泛型方法
静态方法无法使用泛型类中声明的泛型类型 因为泛型类型的确定是创建对象时确定的
而静态方法是先于对象存在的 ，如果要使用，在当前静态方法上声明泛型类型
public static <泛型类型> vaid 方法名()
public class Genric {
public void add(E e) {
}
public static void fun(T ... e) {
}
}
测试：
public class Test {
public static void main(String[] args) {
//使用泛型类
Genric g = new Genric();//对于当前g对象而言 它的泛型E的类型是String
g.add(123);
//声明泛型类 不指定泛型的具体类型
Genric g1 = new Genric();
g1.add("123");// 此时泛型E的类型是String
g1.add(1);//此时泛型类型是Integer
Genric.fun("123");
}
}
interface UserService{
public void fun(T t);
}
class UserServiceImpl implements UserService{
@Override
public void fun(T t) {
// TODO Auto-generated method stub
}
}
反射
学习反射
学习反射：
反射是运行期的行为
Class类：
- 这个类产生的一个实例对象用来描述某个类。 class
这个class对象描述的就是Student类。 - 所有的Student的对象和Student类共享 当前该class对象
- 举例： class
"hehe" "嘻嘻" String类 都共享该class对象
获取Class对象
三种：
- 1：Class.forName(需要获取类的全限定名包名.类名); 最常见的
- 2：类名.class
- 3：对象.getClass
- 4:class对象.getSuperClass 获取父类的class对象3
public class Test02 {
public static void main(String[] args) throws ClassNotFoundException {
//获取一个类的Class对象的方法
Class clz = Class.forName("java.lang.String");
System.out.println(clz);
//获取String的Class对象
Class clz1 = String.class;
System.out.println(clz==clz1);
//获取String对象对应的Class对象
Class clz2 = "zhangsan".getClass();
Class clz3 = "lisi".getClass();
System.out.println(clz1==clz2);
System.out.println(clz2==clz3);
System.out.println(clz3.getSuperclass());
}
}
Class对象的用法
获取属性、方法、构造器
public class Test03 {
public static void main(String[] args) throws ClassNotFoundException, NoSuchFieldException, SecurityException, NoSuchMethodException {
//获取User的class对象
Class clz = Class.forName("com.mage.reff.User");
//获取属性
System.out.println("获取public修饰的指定的属性");
Field f = clz.getField("id");
System.out.println(f.getName()+"=="+f.getType()+"=="+Modifier.toString(f.getModifiers()));
System.out.println("获取public修饰的指定的所有属性");
Field[] fs = clz.getFields();
for(Field ff:fs) {
System.out.println(ff.getName()+"=="+ff.getType()+"=="+Modifier.toString(ff.getModifiers()));
}
System.out.println("获取所有指定的属性");
f = clz.getDeclaredField("name");
System.out.println(f.getName()+"=="+f.getType()+"=="+Modifier.toString(f.getModifiers()));
System.out.println("获取所有属性");
fs = clz.getDeclaredFields();
for(Field ff:fs) {
System.out.println(ff.getName()+"=="+ff.getType()+"=="+Modifier.toString(ff.getModifiers()));
}
System.out.println("获取public修的所有方法 获取父类的");
Method[] ms = clz.getMethods();
for(Method mm:ms) {
System.out.println(Modifier.toString(mm.getModifiers())+"=="+mm.getParameterCount()+"=="+mm.getName());
}
System.out.println("获取public修的指定方法 ");
Method m = clz.getMethod("fun", Integer.TYPE,String.class);
System.out.println(Modifier.toString(m.getModifiers())+"=="+m.getParameterCount()+"=="+m.getName());
System.out.println("获取所有方法 不包含父类的");
ms = clz.getDeclaredMethods();
for(Method mm:ms) {
System.out.println(Modifier.toString(mm.getModifiers())+"=="+mm.getParameterCount()+"=="+mm.getName());
}
System.out.println("获取的指定非public修饰的方法 ");
m = clz.getDeclaredMethod("method", Integer.TYPE,String.class);
System.out.println(Modifier.toString(m.getModifiers())+"=="+m.getParameterCount()+"=="+m.getName());
System.out.println("获取构造器public");
Constructor c = clz.getConstructor(null);
System.out.println(c.getName()+"=="+c.getParameterCount());
System.out.println("获取构造器 非public");
c = clz.getDeclaredConstructor(Integer.TYPE,String.class,Integer.TYPE,Integer.TYPE);
System.out.println(c.getName()+"=="+c.getParameterCount());
System.out.println("获取所有的构造器 public");
Constructor[] cs = clz.getConstructors();
for(Constructor cc:cs) {
System.out.println(cc.getName()+"=="+cc.getParameterCount());
}
System.out.println("获取所有的构造器");
cs = clz.getDeclaredConstructors();
for(Constructor cc:cs) {
System.out.println(cc.getName()+"=="+cc.getParameterCount());
}
}
}
使用反射调用构造器 创建对象
public class Test04 {
public static void main(String[] args) throws NoSuchMethodException, SecurityException, InstantiationException, IllegalAccessException, IllegalArgumentException, InvocationTargetException {
//获取User对于的Class对象
Class clz = User.class;
//获取user对应的指定构造器
Constructor c = clz.getDeclaredConstructor(Integer.TYPE,String.class,Integer.TYPE,Integer.TYPE);
//取消检查
c.setAccessible(true);
//调用构造器
User u = (User) c.newInstance(12,"嘿嘿",11,11);
c.setAccessible(false);
System.out.println(u);
}
}
Tips:
使用反射调用某个非public修饰的构造器时 需要取消检查