黑马程序员---------泛型、Map集合、集合框架工具类

最新推荐文章于 2021-07-26 22:12:27 发布

lv13335152486

最新推荐文章于 2021-07-26 22:12:27 发布

阅读量426

点赞数

分类专栏： JAVA基础日记文章标签： java基础学习技术博客

本文链接：https://blog.csdn.net/lv13335152486/article/details/45148599

版权

JAVA基础日记专栏收录该内容

11 篇文章 0 订阅

订阅专栏

-------------Android培训、java培训、期待与您交流-----------

第1讲

1.1 泛型基本知识

泛型：JDK1.5版本以后出现新特性。用于解决安全问题，是一个类型安全机制。

好处：

1、将运行时期出现问题ClassCastException，转移到了编译时期。，

方便于程序员解决问题。让运行时问题减少，安全。，

2、避免了强制转换麻烦。

泛型格式：通过<>来定义要操作的引用数据类型。

在使用java提供的对象时，什么时候写泛型呢？

通常在集合框架中很常见。

只要见到<>就要定义泛型。

其实<> 就是用来接收类型的。

当使用集合时，将集合中要存储的数据类型作为参数传递到<>中即可。

1.2 泛型类

什么时候定义泛型类？

当类中要操作的引用数据类型不确定的时候，

早期定义Object来完成扩展；现在定义泛型来完成扩展。

泛型类示例：

<span style="font-size:14px;">class Utils<QQ>
{
	private QQ q;
	public void setObject(QQ q)
	{
		this.q = q;
	}
	public QQ getObject()
	{
		<span style="font-family: Arial, Helvetica, sans-serif;">return q;</span>
        }<span style="white-space:pre">	</span>
}</span>

泛型类定义的泛型，在整个类中有效。如果被方法使用，

那么泛型类的对象明确要操作的具体类型后，所有要操作的类型就已经固定了。

为了让不同方法可以操作不同类型，而且类型还不确定，那么可以将泛型定义在方法上。

特殊之处：

静态方法不可以访问类上定义的泛型。

如果静态方法操作的引用数据类型不确定，可以将泛型定义在方法上。

示例：

<span style="font-size:14px;"><span style="font-size:14px;">class Demo<T>
{
	public  void show(T t)
	{
		System.out.println("show:"+t);
	}
	public <Q> void print(Q q)
	{
		System.out.println("print:"+q);
	}
	public  static <W> void method(W w)
	{
		System.out.println("method:"+w);
	}
}</span></span>

1.3泛型定义在接口上

<span style="font-size:14px;"><span style="font-size:14px;">interface Inter<T>
{
	void show(T t);
}
class InterImpl<T> implements Inter<T>
{
	public void show(T t)
	{
		System.out.println("show :"+t);
	}
}</span></span>

1.4 通配符？

占位符

泛型的限定；

？ extends E: 可以接收E类型或者E的子类型。上限。

？ super E: 可以接收E类型或者E的父类型。下限

<span style="font-size:14px;"><span style="font-size:14px;">	public static void printColl(Collection<? extends Person> al)
	{
		Iterator<? extends Person> it = al.iterator();
		while(it.hasNext())
		{
			System.out.println(it.next().getName());
		}
	}</span></span>

泛型限定是用于泛型扩展的。

第2讲 Map集合

Map集合：该集合存储键值对。一对一对往里存，而且要保证键的唯一性。

Map与Collection：

Map与Collection在集合框架中属并列存在

Map存储的是键值对

Map存储元素使用put方法，Collection使用add方法

Map集合没有直接取出元素的方法，而是先转成Set集合，在通过迭代获取元素

Map集合中键要保证唯一性

<span style="font-size:14px;"><span style="font-size:14px;">Map
	|--Hashtable:底层是哈希表数据结构，不可以存入null键null值。该集合是线程同步的。jdk1.0.效率低。
	|--HashMap：底层是哈希表数据结构，允许使用 null 值和 null 键，该集合是不同步的。将hashtable替代，jdk1.2.效率高。
	|--TreeMap：底层是二叉树数据结构。线程不同步。可以用于给map集合中的键进行排序。</span></span>

Set底层就是使用了Map集合。

1.1 Map集合基本操作

1、添加

put(K key, V value)

putAll(Map<? extends K,? extends V> m)

2、删除

clear()

remove(Object key)

3、判断

containsValue(Object value)

containsKey(Object key)

isEmpty()

4、获取

get(Object key)

size()

values()

1.2 map集合的两种取出方式

entrySet()

keySet()

1、Set<k> keySet：将map中所有的键存入到Set集合。因为set具备迭代器。

所有可以迭代方式取出所有的键，在根据get方法。获取每一个键对应的值。

Map集合的取出原理：将map集合转成set集合。在通过迭代器取出。

2，Set<Map.Entry<k,v>> entrySet：将map集合中的映射关系存入到了set集合中，

而这个关系的数据类型就是：Map.Entry

Entry其实就是Map中的一个static内部接口。

为什么要定义在内部呢？

因为只有有了Map集合，有了键值对，才会有键值的映射关系。

关系属于Map集合中的一个内部事物。

而且该事物在直接访问Map集合中的元素。

Map.Entry底层代码：

<span style="font-size:14px;"><span style="font-size:14px;">interface Map
{
	public static interface Entry
	{
		public abstract Object getKey();
		public abstract Object getValue();
	}
}

class HashMap implements Map
{
	class Hahs implements Map.Entry
	{
		public  Object getKey(){}
		public  Object getValue(){}
	}	
}</span></span>

练习：

每一个学生都有对应的归属地。

学生Student，地址String；学生属性：姓名，年龄。

注意：姓名和年龄相同的视为同一个学生。保证学生的唯一性。

对学生对象的年龄进行升序排序。

思路：

1、描述学生

2、自定义一个比较方法，实现Comparator方法

3、定义map容器，将学生作为键，地址作为值，按照年龄进行升序存入。

4、获取map集合中的元素。

<span style="font-size:14px;"><span style="font-size:14px;">import java.util.*;
class Student implements Comparable<Student>
{
	private String name;
	private int age;
	Student(String name,int age)
	{
		this.name = name;
		this.age = age;
	}	
	public int compareTo(Student s)
	{
		int num = new Integer(this.age).compareTo(new Integer(s.age));

		if(num==0)
			return this.name.compareTo(s.name);
		return num;
	}
	public int hashCode()
	{
		return name.hashCode()+age*34;
	}
	public boolean equals(Object obj)
	{
		if(!(obj instanceof Student))
			throw new ClassCastException("类型不匹配");
		Student s = (Student)obj;
		return this.name.equals(s.name) && this.age==s.age;
	}
	public String getName()
	{
		return name;
	}
	public int getAge()
	{
		return age;
	}
	public String toString()
	{
		return name+":"+age;
	}
}
class StuNameComparator implements Comparator<Student>
{
	public int compare(Student s1,Student s2)
	{
		int num = s1.getName().compareTo(s2.getName());
		if(num==0)
			return new Integer(s1.getAge()).compareTo(new Integer(s2.getAge()));

		return num;
	}
}
class  MapTest
{
	public static void main(String[] args) 
	{
		TreeMap<Student,String> tm = new TreeMap<Student,String>(new StuNameComparator());

		tm.put(new Student("blisi3",23),"nanjing");
		tm.put(new Student("lisi1",21),"beijing");
		tm.put(new Student("alisi4",24),"wuhan");
		tm.put(new Student("lisi1",21),"tianjin");
		tm.put(new Student("lisi2",22),"shanghai");	
		Set<Map.Entry<Student,String>> entrySet = tm.entrySet();
		Iterator<Map.Entry<Student,String>> it = entrySet.iterator();
		while(it.hasNext())
		{
			Map.Entry<Student,String> me = it.next();

			Student stu = me.getKey();
			String addr = me.getValue();
			System.out.println(stu+":::"+addr);
		}
	}
}</span></span>

执行结果：

第3讲集合框架工具类

3.1 collections

Collections:集合框架的工具类。里面定义的都是静态方法。

Collections和Collection有什么区别?

Collection是集合框架中的一个顶层接口，它里面定义了单列集合的共性方法。

它有两个常用的子接口，

List：对元素都有定义索引。有序的。可以重复元素。

Set：不可以重复元素。无序。

提供的方法中有可以对list集合进行排序，二分查找等方法。

通常常用的集合都是线程不安全的。因为要提高效率。

如果多线程操作这些集合时，可以通过该工具类中的同步方法，将线程不安全的集合，转换成安全的。

collection基本操作如下：

<span style="font-size:14px;"><span style="font-size:14px;">import java.util.*;

class StrComparator implements Comparator<String>
{
	public int compare(String s1,String s2)
	{
		return s2.compareTo(s1);
	}
}
class StrLenComparator implements Comparator<String>
{
	public int compare(String s1,String s2)
	{
		if(s1.length()>s2.length())
			return 1;
		if(s1.length()<s2.length())
			return -1;
		return s1.compareTo(s2);
	}
}
class CollectionsDemo2 
{
	public static void main(String[] args) 
	{
		shuffleDemo();
	}
	public static void orderDemo()
	{
		List<String> list = new ArrayList<String>();

		list.add("abcd");
		list.add("aaa");
		list.add("zz");
		list.add("kkkkk");
		list.add("qq");
		list.add("z");
		//Collections.fill(list,"pp");//将集合中所有的元素变成pp
		Collections.replaceAll(list,"aaa","pp");将集合中所有的aaa变成pp
		Collections.reverse(list);//反转集合
		Collections.shuffle(list);//使用默认随机源对指定列表进行置换         
		Collections.sort(list);//对集合进行默认顺序的排序
		Iterator it = list.iterator();
		while(it.hasNext())
		{
			System.out.println(it.next());
		}
	}</span></span>

解决线程安全问题：

synchronizedList<list<T> list>

synchronizedMap<Map<K,V> m>

synchronizedSet<Set<T> s>

返回指定集合支持的同步，顺利解决了安全问题。

3.2 Arrays

Arrays:用于操作数组的工具类。

里面都是静态方法。

asList:将数组变成list集合

把数组变成list集合的好处：

可以使用集合的思想和方法来操作数组中的元素。

注意：将数组变成集合，不可以使用集合的增删方法。

因为数组的长度是固定。

如果数组中的元素都是对象。那么变成集合时，数组中的元素就直接转成集合中的元素。

如果数组中的元素都是基本数据类型，那么会将该数组作为集合中的元素存在。

集合变数组：

1、指定类型的数组到底要定义多长呢？

当指定类型的数组长度小于了集合的size，那么该方法内部会创建一个新的数组。长度为集合的size。

当指定类型的数组长度大于了集合的size，就不会新创建了数组。而是使用传递进来的数组。

所以创建一个刚刚好的数组最优。

2、为什么要将集合变数组？

为了限定对元素的操作。不需要进行增删了。

3.3 高级for循环

格式：

for(数据类型变量名 : 被遍历的集合(Collection)或者数组)

{
执行语句；
}

高级for循环对集合进行遍历。

只能获取集合元素。但是不能对集合进行操作。

迭代器除了遍历，还可以进行remove集合中元素的动作。

如果是用ListIterator，还可以在遍历过程中对集合进行增删改查的动作。

传统for和高级for有什么区别呢？

高级for有一个局限性。必须有被遍历的目标。

建议在遍历数组的时候，还是希望是用传统for。因为传统for可以定义脚标。

<span style="font-size:14px;"><span style="font-size:14px;">int[] arr = {3,5,1};
for(int i : arr)
{
	System.out.println("i:"+i);
}</span></span>

lv13335152486

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
黑马程序员---------泛型、Map集合、集合框架工具类

第1讲1.1 泛型基本知识泛型：JDK1.5版本以后出现新特性。用于解决安全问题，是一个类型安全机制。好处： 1、将运行时期出现问题ClassCastException，转移到了编译时期。，方便于程序员解决问题。让运行时问题减少，安全。， 2、避免了强制转换麻烦。泛型格式：通过在使用java提供的对象时，什么时候写泛型呢？通常在集合框
复制链接

扫一扫