core java--day11(List，map，集合对比总结图，泛型，反射)

于 2019-08-18 11:47:09 发布
阅读量278 收藏
点赞数
CC 4.0 BY-SA版权
分类专栏： java 文章标签： List Map 集合对比总结图 泛型 反射
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/qq_41533897/article/details/99702997
本文主要复习了Java中的包装器类，如Integer的自动装箱与拆箱，以及集合类如List、Set、Map的特性。在List中对比了ArrayList、LinkedList和Vector的特点。探讨了Map的HashMap、HashTable和TreeMap，并介绍了它们的遍历方式。还讨论了泛型的概念和作用，以及如何在类名和方法中使用泛型。最后，简述了反射机制，包括通过Class对象获取类信息、创建对象、访问属性和方法等。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

复习：

1,包装器
   Integer
   //把字符串转换为数字
   Integer.parseInt();

   jdk1.5 自动装箱
   Integer a = Integer.valueOf("123");
   Integer a = 123;
   
   自动拆箱 :
   int b = a.intValue();
   int b = 1;
   
   Integer i = 128;
   Integer o = 128;
   i==o  false      i>-128&&i<=127
            new Integer(i);

集合 :
    set :
    1,无序
    2,不能重复
    list
    1,有序:添加的顺序
    2,能重复
    map
        1,key - value
    2,key 唯一
    3,value 可以相同

  Collection      map
  list  set       map
  
  Collection:
      add();
      remove();
      contains();
      size();
      clear();
      iterator();迭代器

 HashSet:
    Hash表 : HashCode 不同, 保存
         HashCode 同  , equals 

 TreeSet : 可以排序的set集合
      手动制定排序规则。
      Comparator<> com = new Comparator(){
          int compare(o1,o2){
       -1  o1 <  o2
       1   o1 >  o2
       0   o1 == o2
        return 1  -1   0;
      }
      };
      new TreeSet(com);

自然排序:
    设计者,在构建项目给类(对象)指定排序规则.
      1,构建类 javaBean : 只用来封装数据的类
        public class Student{
      private int id;
      private String name;
    }
      2,实现Comparable<类>
      3,重写compareTo方法
      4,构建TreeSet对象
      5,使用TreeSet对象 添加 Student对象

10.8 List : 线性方式(数组)存储.
    10.8.1:ArrayList : 代表长度可变的数组。允许对元素进行快速的随机访问，但是向ArrayList中插入与删除元素的速度较慢；
    10.8.2:LinkedList: 在实现中采用链表结构。对顺序访问进行了优化，向List中插入和删除元素的速度较快，随机访问速度则相对较慢。
    10.8.3:Vector    : 是线程安全的集合
    10.8.4:集合操作实例
        注意：在使用List接口的时候注意导包.需要导入的是java.util.List包。
        List list =new ArrayList();
        list.add("小明");
        list.add("小红");
        list.add("小明");
        list.add("小红");

        list.size();
        list.remove(index);
        list.remove(object);
        
        Iterator it = list.iterator();
        while(it.hashNext()){
            String name = (String)(it.next());
        }

        list.get(index);

        for(int i = 0;i<list.size();i++){
            String name = list.get(i);
        }

10.9: forEach 遍历 Collection集合--> 加强for循环
    for(String s : set){
        syso(s);
    }
10.10:Map  :  
      1,把键对象和值对象进行映射的集合，  它的每一个元素都包含一对键对象和值对象。
      2,向Map集合中加入元素时,   必须提供一对键对象和值对象. 
    map.put(key,value);
      3,从Map集合中检索元素时，只要给出键对象，就会返回对应的值对象。
       value = map.get(key);
      4,Map集合中的键对象不允许重复, 如果有多个相同的key那么上一次的值会被覆盖。
   
   10.1: HashMap  :是线程不安全的集合。
   10.2: HashTable:是线程安全的集合。
   10.3: TreeMap  :可以进行排序(对key进行排序)

 

hashmap与hashtable的区别：

hashmap是非线程安全的，适合与单线程环境；键和值都允许有null存在；

hashtable是线程安全的，是同步的，适合于多线程环境，但效率低；

hashtable是遗留类，有很多内部实现没有优化，一般不用

  
   10.4: HashMap  : 
    判断key是否相同是通过
    hashCode &&  equals方法来判断。
   
   10.5: TreeMap  :  实现了SortedMap接口，能对 键对象(key) 进行排序。
   10.10.5.1 :  自然排序(默认) : 实现了Comparable接口 ,重写  compareTo(Object o);    
   10.10.5.2 :  客户端排序     : 创建比较器--->实现java.util.Comparator接口,重写compare(Object x, Object y)方法。构造器传入TreeMap Eg:new TreeMap(比较器);
   
   10.6:map的遍历
   1,map.entrySet()+forEach版本
       Set entrySet = map.entrySet();
       for(Entry a: entrySet){
           System.out.println(a.getKey()+"--------"+a.getValue());
       }
   2, keySet() + 迭代器
       Set keySet = map.keySet();
       Iterator itKey = keySet.iterator();
       while(itKey.hasNext()){
           Object key = itKey.next();
           System.out.println(key + "---"+map.get(key));
       }
   3, keySet() + forEach
       Set keySet = map.keySet();
       for(Object key: keySet){
           System.out.println(key+"----"+map.get(key));
       }
   
 

package com.briup.ch11;

/**
 * 自然排序<br>
 * */
public class Student implements Comparable<Student>{
	
	private int id;
	private String name;
	/**
	 * 自然排序<br>
	 * 当 Student类的对象被添加到TreeSet中的时候,<br>
	 * 就会自动触发 这个方法进行比较<Br>
	 * this是当前添加的数据<Br>
	 * o是 集合中原有的数据<br>
	 * this 和 参数 o 进行比较<br>
	 * 0   
	 * 正数  
	 * 负数  
	 * */
	@Override
	public int compareTo(Student o) {
		//id越小越前面
		int nid = this.id;//当前的id          1
		int oid = o.getId();//集合中对象的id  3
		
		String nName = this.name;
		String oName = o.getName();
		
		return nid-oid;
	}
	
	
	public void show() {
		System.out.println("1");
	}
	public void show(int i) {
		System.out.println("2"+i);
	}
	
	
	
	
	public Student(int id, String name) {
		super();
		this.id = id;
		this.name = name;
	}
	public Student() {
		super();
	}
	
	
	

	public int getId() {
		return id;
	}
	public void setId(int id) {
		this.id = id;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	@Override
	public String toString() {
		return "Student [id=" + id + ", name=" + name + "]";
	}
	
}

package com.briup.ch11;

import java.util.Set;
import java.util.TreeSet;

/**
 * 测试 Student类的 自然排序<br>
 * */
public class Test1 {
	
	
	public static void main(String[] args) {
		//TreeSet 可以排序
		Set<Student> treeSet = new TreeSet<>();
		
		treeSet.add(new Student(3, "wangwu"));
		treeSet.add(new Student(2, "lisi"));
		treeSet.add(new Student(1, "tom"));
		treeSet.add(new Student(4, "zhaoliu"));
		
		System.out.println(treeSet);
		
	}
	
	
	
	
}

package com.briup.ch11;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

/**
 * 测试ArrayList
 * */
public class Test2 {
	public static void main(String[] args) {
		//list集合
		List list = new ArrayList<>();
		list.add(23);
		list.add("tom");
		list.add(true);
		list.add(10.8);
		list.add(true);
		//打印list集合
		System.out.println(list);
		list.add(1, "lisi");
		System.out.println(list);
		
		//list.remove(2);
		while(list.contains(true)) {
			list.remove(true);
		}
		System.out.println(list);
		//获取长度
		int size = list.size();
		//获取迭代器
		Iterator iterator = list.iterator();
		//判断是否有下一个
		while(iterator.hasNext() ) {
			//游标 下移
			System.out.println( iterator.next() );
		}
		//通过下标获取数据
		int object = (int) list.get(0);
		System.out.println(object);
		//遍历list数组
		for(int i = 0;i<list.size();i++) {
			System.out.println( list.get(i)  );
		}
	}
}

package com.briup.ch11;

import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;

/**
 * HashMap测试<br>
 * */
public class Test3 {
	
	
	public static void main(String[] args) {
		//hashMap
		Map map = new HashMap();
		map.put("1", "tom");
		map.put(1, "lisi");
		//比较key 是否相同，
		//先 hashCode 再 equals 
		map.put(new Student(1,"tom"), 10);
		
		map.put("h", 1);
		
		//判断map集合中是否包含 h 这个key
		map.containsKey("h");
		//使用h 这个key  获取value值
		int object = (int) map.get("h");
		object++;
		//重复 存放 h - value  会覆盖以前的 k - v 键值对
		map.put("h", object);
		
		System.out.println(map);
		//hello world
		
		//通过key 移除 key-value 键值对
		map.remove("h");
		
		
		//遍历map
		Set keySet = map.keySet();//把所有key获取 设置到set集合中
		Iterator iterator = keySet.iterator();
		while(iterator.hasNext()) {
			Object key = iterator.next();
			//通过map中的key 获取 map中value值
			Object obj = map.get(key);
			System.out.println(obj);
		}
		
		//HashMap 和  HashSet 
		
		// HashMap是底层实现
		// 内部接口 Entry{ k , v  }
		// Node implements Entry{}
		// HashSet中 维护了一个HashMap
		
	}
}

package com.briup.ch11;

import java.util.Comparator;
import java.util.Map;
import java.util.TreeMap;

/**
 * 测试TreeMap
 * */
public class Test4 {
	public static void main(String[] args) {
		Comparator com = new Comparator() {

			@Override
			public int compare(Object o1, Object o2) {
				return 1;
			}
		};
		
		//对key进行排序
		Map map = new TreeMap(com);
		
		map.put("tom", 12);
		map.put("lisi", "123");
		System.out.println(map);
		
		
		Map mapstu = new TreeMap();
		mapstu.put(new Student(2, "lisi"), 70);
		mapstu.put(new Student(3, "wangw"), 80);
		mapstu.put(new Student(1, "tom"), 2);
		
		System.out.println(mapstu);
		
		
	}
}

泛型 :  用于约束代码.用于灵活代码.//确定数据的类型，用户自定义数据类型，为了在编译其间判断是否相符
          
      约束，统一操作
      1,写在类名后面
      2,方法返回值前面
      3,方法参数位置

    11.1: 集合加泛型:约束该集合只能添加泛型类型的数据.【编译时泛型】
    
        11.1.1 : List集合
           语法：List<String> list = new ArrayList<String>();--->生成的.class文件中:List l = new ArrayList();
                 表示该集合list只能添加String类型的数据。发生在编译期间.
             list.add("abc");  √
             list.add(123);    ×
        
        11.1.2 : Set集合
           语法: Set<Book> books = new HashSet<Book>();
             表示该set集合只能添加book类型的数据。不然编译通不过。
        
        11.1.3 : Map集合
           语法: Map<String,String> map = new HashMap<String,String>();
                 表示该map集合只能保持key为String,value为String的数据对。
        
        注意 : 集合中泛型只能是类类型.
    11.2: 类名后加泛型: 代码更加灵活.
        11.2.1:语法：
            public  class TestBean<T>  {
                public  T show(T t){}
            }
        11.2.2:使用：
            TestBean<Integer> a  = new TestBean<Integer>();
            Integer value = a.show(123);

            TestBean<String> a  = new TestBean<String>();
            String value = a.show("acb");
        11.2.3: 类名后加两/多个泛型
            public  class TestBean<T,K,V>  {
                Map<K,V> map = new HashMap<K,V>();
                public V show(K key){
                    return map.get(key);
                }
            }
            TestBean<Boolean,String,Integer> t = new TestBean<Boolean,String,Integer>();
            Integer a = t.show("tom");

    11.3：泛型解决的问题
          11.3.1:泛型可以使类中的属性的类型可以由外部决定
          11.3.2:不需要强制类型转换
          11.3.3:泛型可以在*编译期间*进行类型检查
          11.3.4:提供了类型安全的操作

    附：    K —— 键，比如映射的键。
        V —— 值，比如 List 和 Set 的内容，或者 Map 中的值。
        E —— 异常类。
        T —— 泛型。

package com.briup.ch11;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
/**
 * 泛型里面只能写引用数据类型
 * */
public class Test5 {
	public static void main(String[] args) {
		
		List<Student> list1 = new ArrayList<>();
		List<String> list2 = new ArrayList<>();
		List<Integer> list3 = new ArrayList<>();
		
		List<int[]> list4 = new ArrayList<>();
		
		
		list3.add(3);
		list3.add(22);
		for(int i = 0;i<list3.size();i++) {
			Integer integer = list3.get(i);
			System.out.println(integer);
		}
		
		
		List<List<String>> list5 = new ArrayList<>();
		//map集合使用泛型
		//k  : Integer
		//v  : String
		Map<Integer, String> m1 = new HashMap<Integer, String>();
		m1.put(20, "tom");
		
		Map<Integer, Student> m2 = new HashMap<Integer, Student>();
		m2.put(2, new Student(2,"tom"));
		
		Map<String, Student> m3 = new HashMap<String, Student>();
		m3.put("tom", new Student(1,"tom"));
		
		
		
		Map<Student, Integer> m4 = new HashMap<Student, Integer>();
		m4.put(new Student(1,"tom"), 10);
		m4.put(new Student(2,"lisi"), 90);
		
		//hello world
		Map<Character,Integer> m5 = new HashMap<>();
		
		
		
	}
}

package com.briup.ch11;

public class School {
	//    声明泛型   返回值     声明泛型类型的变量
	// 当前声明的泛型只对该方法生效
	public <T>  T show(T t) {
		
		return t;
	}
	
	
}

package com.briup.ch11;
/**
 * 配合School测试泛型
 * */
public class Test6 {
	public static void main(String[] args) {
		
		School sc = new School();
		Integer show = sc.show(10);
		
		String show2 = sc.show("tom");
		
		Student show3 = sc.show(new Student());
		
		//字符串 需要被保护
		Ba<String> b1 = new Ba<String>();
		b1.show("tom");
		b1.eat("abc");
		
		Ba<Student> b2 = new Ba<Student>();
		b2.show(new Student());
		b2.eat(new Student());
		
		
	}
}

package com.briup.ch11;
/**
 * 保安公司
 * */
//声明了一个全局泛型,再当前类中有效
public class Ba <S> {
	
	public void insert(S s) {
		
		
	}
	public void delete(S s) {
		
	}
	
	
	
	public void show(S s) {
		
	}
	public void say(S s) {
		
	}
	public void eat(S s) {
		
	}
	
	
}

十二 : 反射
    利用类加载时在堆中创建的java.lang.Class对象去获得该类加载以后在方法区中创建的类信息,方法信息,变量信息...
    
    
    12.1 : Class c = Class.forName("[类全包名+类名]/[全限定名]");//通过类加载器加载全限定名所对应的类.--->类加载--->涉及到内存问题.回顾 2.5
        //利用 该类的Class对象可以创建对象,访问属性,访问方法,访问构造器
    12.2 : 创建对象: c.newInstance();
    12.3 : 获得属性镜像: Field field = c.getField("属性名");
            Field[] fields = c.getFields();
            Field[] fields = c.getDeclaredFields();
    
    12.4 : 获得方法镜像: Method method = c.getMethod("方法名",参数1.class,参数2.class...);
            Method method = c.getDeclaredMethod("方法名",,参数1.class,参数2.class...);
            如果是私有属性需要设置可见性:method.setAccessible(true);
            设置可见性: Method.setAccessible(methodarray, flag);

        12.4.1:利用方法镜像调用目标对象的方法:
            Object returnValue = method.invoke(obj, args...);
        12.4.2:利用方法镜像获得方法的返回值类型
            method.getGenericReturnType();
        12.4.3:利用方法镜像获得方法的修饰符
            method.getModifiers() 
        12.4.4:利用方法镜像获得方法名
            method.getName();
        12.4.5:利用方法镜像获得方法的参数列表
            method.getGenericParameterTypes();
        12.4.6:利用方法镜像获得方法的异常
            method.getGenericExceptionTypes();

        注意：method,是一个方法的镜像,只能对应一个方法。


    12.5 : 获取构造器镜像:Constructor<?>[] constructors = c.getConstructors();
             Constructor<?> constructor2 = c.getConstructor(参数1.class,参数1.class,...);
            
        
        12.5.1:利用构造器镜像 创建对象
            constructor.newInstance(参数,参数,...);//用有参构造器创建对象

        注意：反射创建对象有两种方式:
            1,直接用class.newInstance();//调用无参构造器创建对象
            2,利用class获得有参构造器,然后调用newInstance(参数...);
    12.6 : 获取注解镜像:getDeclaredAnnotations(); 或者 getAnnotations();
        注:获取方法上的注解就使用  method.getAnnotations();或者    method.getDeclaredAnnotations();
           获取属性上的注解就使用  field.getAnnotations();...

package com.briup.ch11;

import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;

import javax.print.attribute.standard.Fidelity;

/**
 * 反射<br>
 * */
public class Test7 {
	public static void main(String[] args) throws NoSuchFieldException, SecurityException, NoSuchMethodException, InstantiationException, IllegalAccessException, IllegalArgumentException, InvocationTargetException {
		//1,获取某个类的 class 引用
		Class<Student> sclass = Student.class;
		//属性 Field   方法  Method  构造器  Constructor
		//Student类中id属性对应的对象
		//不能查找private修饰的方法和属性
//		Field field = sclass.getField("id");
//		String name = field.getName();
//		String string = field.getType().toString();
//		System.out.println(name+"--"+string);
		
		//查找private修饰的变量和 方法
		Field field = sclass.getDeclaredField("id");
		//设置私有属性的可见性
		field.setAccessible(true);
		System.out.println(field.getName());
		System.out.println(field.getType().toGenericString());
		
		
		// Student 类中的方法
		//sclass.getMethod("方法名", "参数列表的类型".getClass());
		
//		public void show() 
//		public void show(int i)
		
		//反射创建对象
		Student student = sclass.newInstance();
		
		//方法对象public void show() 
		Method method = sclass.getMethod("show");
		
		//调用方法
		method.invoke(student);
		
		
		//public void show(int i) 
		Method method2 = sclass.getMethod("show", int.class);
		method2.invoke(student, 45);
		
		
	}
}

 

评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值