黑马程序员-----集合（二）

最新推荐文章于 2024-03-22 18:47:18 发布

Heima_aria

最新推荐文章于 2024-03-22 18:47:18 发布

阅读量341

点赞数

分类专栏：黑马程序员

本文链接：https://blog.csdn.net/Heima_aria/article/details/7729485

版权

黑马程序员专栏收录该内容

16 篇文章 0 订阅

订阅专栏

---------------------- android培训、java培训、期待与您交流！

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();

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

map的取出方式

第一种取出方式： Set<k> keySet();将map中所有的键存入到set集合。因为set具备迭代器。所有可以迭代方式取出所有的键，再根据get方法，获取每一个键对应的值

　　　1,先获取map集合的所有键的Set集合，keySet();　　如：Set<String> keySet = map.keySet();

2,有了set集合，就可以获取其迭代器。如：

Iterator<String> it = keySet.iterator();

while(it.hasNext())

{

String key = it.next();

//3,有了键就可以根据map集合的get方法获取其对应的值

String value = map.get(key);

sop("key: "+key+" value: "+value);

}

第二种取出方式：Set<Map.Entry<k,v>> entrySet(); 将map集合中的映射关系存入到set集合中，而这个关系的数据类型就是：Map.Entry

　　　1,将map集合中的映射关系取出。存入到Set集合中. 如：

Set<Map.Entry<String,String>> entrySet = map.entrySet();

Iterator<Map.Entry<String,String>> it = entrySet.iterator();

while(it.hasNext())

{

Map.Entry<String,String> me = it.next();

String key = me.getKey();

String value = me.getValue();

sop(key+"::"+value);

}

Map.Entry 其实Entry也是一个接口，它是Map接口中的内部接口。

interface Map

{

public static interface Entry

{

public abstract Object getKey();

public abstract Object getValue();

}

class HashMap implements Map

{

Class Hahs implements Map.Entry

{

public abstract Object getKey(){}

public abstract Object getValue(){}

}

Map

|--Hashtalbe:底层是哈希表数据结构，不可以存入null键null值。该集合是线程同步的。

|--HashMap：底层是哈希表数据结构，可以存入null键null值，该集合是不同步的。

|--TreeMap：底层是二叉树数据结构，线程不同步。可以用于给map集合中的键进行排序

Utilities 集合工具类

Collections

排序

sort(List<T> list);

sort(List<T> list,Comparator<? Super T> c);

最大值

max(Collection<? extends T> coll);

max(Collection<? extends T> coll, Comparator<? super T> comp);

折半查找

binarySearch(List<? Extends Comparable<? super T>> list, T key);

binarySearch(List<? Extends Comparable<? super T>> list, T key,Comparator<? super T> c);

替换集合所有元素

fill(List<? super T> list, T obj) 将list集合中的所有元素替换成指定元素

replaceAll(List<T> list, T oldVal, T newVal) 将集合中的某个元素替换成指定元素

reverse(List<?> list); 将集合元素进行反转

comparator<T> reverseOrder(); 返回一个比较器,它强行逆转实现了Comparable接口的对象collection的自然顺序。

comparator<T> reverseOrderComparator<T> cmp();强行逆转比较器的顺序。

List<T> synchronizedList(List<T> list)

swap(List<?> list,int i , int j) 置换

shuffle(List<?> list) 使用默认随机源对指定列表进行置换 //应用：扑克洗牌、骰子

数组变集合：

Arrays：用于操作数组的工具类，都是静态方法

asList();将数组变成List集合

把数组变成list集合有什么好处？可以使用集合的思想和方法操作数组中的元素。

注意：将数组变成集合，不可以使用集合的增删方法，因为数组长度是固定的。如果你增删了，那么会发生UnsupportedOperationException

如果数组中的元素都是对象，那么变成集合时，数组中的元素就直接转成集合中元素；如果数组中的元素都是基本数据类型，那么会将数组作为集合中的元素存在。

如：String[] str = {“aaa”,”bbb”,”ccc”}

List list = Arrays.asList(str);

System.out.println(list); //[aaa,bbb,ccc]

int[] str = {1,2,3}

List list = Arrays.asList(str);

System.out.println(list); //**@** hashCode

集合变数组：

使用Collection接口中的 toArray();

如：String[] arr = al.toArray(new String[al.size()]);

System.out.println(Arrays.toString(arr));

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

当指定类型的数组长度小于了集合的size，那么该方法内部会创建一个新的数组，长度为集合的size；当指定类型的数组长度大于了集合的size，就不会新创建了数组，而是使用传递进来的数组，所以创建一个刚刚好的数组最优。

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

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

高级for循环：对集合进行遍历，只能获取集合元素，但是不能对集合进行操作。

格式：

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

｛

｝

如：

HashMap<Integer,String> hm = new HashMap<Integer,String>();
hm.put(1,"a");
hm.put(2,"b");
hm.put(3,"c");
Set<Integer> keySet = hm.keySet();
for(Integer i : keySet)
{
 System.out.println(i+"::"+hm.get(i));
}

Set<Map.Entry<Integer,String>> entrySet = hm.entrySet();
for(Map.Entry<Integer,String> me : entrySet)
{
 System.out.println(me.getKey()+"..."+me.getValue());
}

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

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

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

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

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

JDK1.5版本后出现的新特性：

可变参数：其实就是数组参数的简写形式，不用每次手动建立数组对象。只要将要操作的元素作为参数传递即可。隐式将这些参数封装成了数组

如：show(2,3,4,5,6);

Public static void show(int… arr) //可变参数

{

System.out.println(arr);

}