黑马程序员_java基础7--Map和Collections和Arrays

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

@@(day16)Map和Collections-Arrays工具类和其他对象***********************************************************************

/*

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

1，添加。

put(K key, V value) //返回被覆盖的值！没有则为null。

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

2，删除。

clear()

remove(Object key)

3，判断。

containsValue(Object value)

containsKey(Object key)

isEmpty()

4，获取。

get(Object key) //没有则返回null

size()

values() //返回值 的集合。Collection<Integer> coll = map.values();

5取出方式

Set<String> keySet = map.keySet(); V value = map.get(K key)

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

Map

|--Hashtable:底层是哈希表数据结构，不可以存入null键null值。该集合是线程同步的。jdk1.0.效率低。

|--HashMap：底层是哈希表数据结构，允许使用 null 值和 null 键，该集合是不同步的。将hashtable替代，jdk1.2.效率高。

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

Hashtable和HashMap用作键的对象必须实现 hashCode 方法和 equals 方法

和Set很像。

其实大家，Set底层就是使用了Map集合。

@@map集合的两种取出方式：

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

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

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

/*

//先获取map集合的所有键的Set集合,keySet();

Set<String> keySet = map.keySet();

//有了Set集合。就可以获取其迭代器。

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

while(it.hasNext())

{

String key = it.next();

//有了键可以通过map集合的get方法获取其对应的值。

String value = map.get(key);

System.out.println("key:"+key+",value:"+value);

}

*/

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

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

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

为什么要定义在内部呢？

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

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

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

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

System.out.println(key+":"+value);

}

@@一个重要的例子：

import java.util.*;

class Person implements Comparable<Person>

{

private String name;

private int age;

Person(String name,int age)

{

this.name = name;

this.age = age;

}

public boolean equals(Object obj)

{

if(!(obj instanceof Person))

return false;

Person p = (Person)obj;

return this.name==p.name && this.age==p.age;

}

public int hashCode()

{

return this.name.hashCode()+this.age*33;

}

public int compareTo(Person p)

{

int num = this.name.compareTo(p.name);

if(num == 0)

return (this.age-p.age);

return num;

}

public void setName(String name)

{

this.name = name;

}

public String getName()

{

return this.name;

}

public void setAge(int age)

{

this.age = age;

}

public int getAge()

{

return this.age;

}

public String toString()

{

return name+"的年龄是"+age;

}

}

class demo

{

public static void sop(Object obj)

{

System.out.println(obj);

}

public static void main(String[] args)

{

Map<Person,String> map = new HashMap<Person,String>();

map.put(new Person("java01",11),"北京");

map.put(new Person("java02",22),"南极");

map.put(new Person("java01",11),"上海");

Collection<String> al = map.values();

sop(al);//打印结果 [南极,上海]

sop(map);//打印结果 {java02的年龄是22=南极,java01的年龄是11=上海}

//第一种方法取出map集合中的元素

Set<Person> keySet = map.keySet();

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

while(it.hasNext())

{

Person key = it.next();

String value = map.get(key);

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

}

//第二种方法取出map集合中的元素

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

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

while(it2.hasNext())

{

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

Person key = me.getKey();

String value = me.getValue();

sop(key+"="+value);

}

//打印字符串中每个字符出现的次数。

String s = charCount("sdfgzxcv66dfs5asdfx--cvdfxxx");

sop(s);

}

//打印字符串中每个字符出现的次数。

public static String charCount(String str)

{

Map<Character,Integer> map = new TreeMap<Character,Integer>();

char[] ch = str.toCharArray();

int count = 0;

for(int x = 0;x<ch.length;x++)

{

if( !(ch[x]>='a'&&ch[x]<='z'||ch[x]<='Z'&&ch[x]>='A') )

continue;

Integer value = map.get(ch[x]);

if(value!=null)

count = value;

count++;

map.put(ch[x],count);

count = 0;//************************重点

}

sop(map);

Iterator<Character> it = map.keySet().iterator();

StringBuilder sb = new StringBuilder();

while(it.hasNext())

{

Character key = it.next();

Integer value = map.get(key);

sb.append(key+"("+value+")");

}

return sb.toString();

}

}

@@(day17Collections和Arrays工具类)**********************************************************************

@@Collections 工具类(内部方法都是静态的)

集合框架的工具类。

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

Collections和Collection有什么区别？

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

它有两个常用的子接口，

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

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

Collections是集合框架中的一个工具类。该类中的方法都是静态的

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

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

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

1==sort()*****************************只对List进行排序~~~~~~~~~~

static <T extends Comparable<? super T>> void

sort(List<T> list)

根据元素的自然顺序 对指定列表按升序进行排序。

static <T> void

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

根据指定比较器产生的顺序对指定列表进行排序。

------------------------------------------------------------------

2==max()--min()************************求Collection的最大最小值~~~~~~~~

static <T extends Object & Comparable<? super T>> T

max(Collection<? extends T> coll)

根据元素的自然顺序，返回给定 collection 的最大元素。

static <T> T

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

根据指定比较器产生的顺序，返回给定 collection 的最大元素。

static <T extends Object & Comparable<? super T>> T

min(Collection<? extends T> coll)

根据元素的自然顺序 返回给定 collection 的最小元素。

static <T> T

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

根据指定比较器产生的顺序，返回给定 collection 的最小元素。

--------------------------------------------------------------------

3==binarySearch**找不到则返回(-(插入点)-1)*****只对有序的List中的元素进行查找~~~~~

static <T>

int binarySearch(List<? extends Comparable<? super T>> list, T key)

使用二分搜索法搜索指定列表，以获得指定对象。

static <T>

int binarySearch(List<? extends T> list, T key, Comparator<? super T> c)

使用二分搜索法搜索指定列表，以获得指定对象。

-——————————————————————————————————————————————————————————————————————————————————

4==fill***将List中的元素全部换成obj****==replaceAll替换List中的一个元素。

static <T>void

fill(List<? super T> list, T obj)

使用指定元素替换指定列表中的所有元素。

static <T> boolean

replaceAll(List<T> list, T oldVal, T newVal)

使用另一个值替换列表中出现的所有某一指定值。

———————————————————————————————————————————————————————————————————————————————

5==reverse反转，**************交换swap***************

static void

reverse(List<?> list)

反转指定列表中元素的顺序。

static <T> Comparator<T>

reverseOrder()

返回一个比较器，它强行逆转实现了 Comparable 接口的对象 collection 的自然顺序。

static <T> Comparator<T>

reverseOrder(Comparator<T> cmp)

返回一个比较器，它强行逆转指定比较器的顺序。

static void

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

在指定列表的指定位置处交换元素。

———————————————————————————————————————————————————————————————————————————————

6将不同步的集合变为同步的集合==原理：将原来不同步的集合中的方法中的语句用同步代码块封装下。

static <T> Collection<T>

synchronizedCollection(Collection<T> c)

返回指定 collection 支持的同步（线程安全的）collection。

static <T> List<T>

synchronizedList(List<T> list)

返回指定列表支持的同步（线程安全的）列表。

static <K,V> Map<K,V>

synchronizedMap(Map<K,V> m)

返回由指定映射支持的同步（线程安全的）映射。

static <T> Set<T>

synchronizedSet(Set<T> s)

返回指定 set 支持的同步（线程安全的）set。

static <K,V> SortedMap<K,V>

synchronizedSortedMap(SortedMap<K,V> m)

返回指定有序映射支持的同步（线程安全的）有序映射。

static <T> SortedSet<T>

synchronizedSortedSet(SortedSet<T> s)

返回指定有序 set 支持的同步（线程安全的）有序 set。

———————————————————————————————————————————————————————————————————————————————

7==将列表中的元素位置进行 随机置换。

static void shuffle(List<?> list)

使用默认随机源对指定列表进行置换。

static void shuffle(List<?> list, Random rnd)

使用指定的随机源对指定列表进行置换。

———————————————————————————————————————————————————————————————————————————————

@@Arrays

static <T> List<T>

asList(T... a)

返回一个受指定数组支持的固定大小的列表。

static int binarySearch(byte[] a, byte key)

使用二分搜索法来搜索指定的 byte 型数组，以获得指定的值。

static byte[] copyOf(byte[] original, int newLength)

复制指定的数组，截取或用 0 填充（如有必要），以使副本具有指定的长度。

static byte[] copyOfRange(byte[] original, int from, int to)

将指定数组的指定范围复制到一个新数组。

static boolean equals(byte[] a, byte[] a2)

如果两个指定的 byte 型数组彼此相等，则返回 true。

static void fill(byte[] a, int fromIndex, int toIndex, byte val)

将指定的 byte 值分配给指定 byte 型数组指定范围中的每个元素。

static int hashCode(byte[] a)

基于指定数组的内容返回哈希码。

static void sort(byte[] a, int fromIndex, int toIndex)

对指定 byte 型数组的指定范围按数字升序进行排序。

static String toString(byte[] a)

返回指定数组内容的字符串表示形式。

static <T> List<T>

asList(T... a)

返回一个受指定数组支持的固定大小的列表。

@@==》将数组变成List集合

//把数组变成list集合有什么好处？

/*

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

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

因为数组的长度是固定。

contains。

get

set

indexOf()

subList();

如果你增删。那么会反生UnsupportedOperationException,

*/

int[] nums = {2,4,5};

List<int[]> li = Arrays.asList(nums);

Integer[] nums = {2,4,5};

List<Integer> li = Arrays.asList(nums);

/*

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

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

*/

@@==》集合变成数组toArray()

Object[] toArray()

返回包含此 collection 中所有元素的数组。

<T> T[]

toArray(T[] a)

返回包含此 collection 中所有元素的数组；返回数组的运行时类型与指定数组的运行时类型相同。

如果指定的数组T[] a能容纳列表，则将该列表返回此处。

否则，将分配一个具有指定数组的运行时类型和此列表大小的新数组。

如果指定的数组能容纳队列，并有剩余的空间（即数组的元素比队列多），

那么会将数组中紧接 collection 尾部的元素设置为 null。

/*

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

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

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

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

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

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

*/

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

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

@@增强for循环。(JDK1.5后) 底层封装了迭代器

在能使用迭代器的地方，如果只是想将集合或数组中的元素进行 获取操作，使用foreach简单些。、

高级for循环

格式：

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

{

}

对集合进行遍历。

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

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

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

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

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

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

@@可变参数(JDK1.5后)

方法的可变参数。

在使用时注意：可变参数一定要定义在参数列表最后面。

/*

可变参数。

其实就是上一种数组参数的简写形式。

不用每一次都手动的建立数组对象。

只要将要操作的元素作为参数传递即可。

隐式将这些参数封装成了数组。

*/

public static void show(String str,int... arr)

{

System.out.println(arr.length);

}

show("haha",2,3,4,5,6);

show(2,3,4,5,6,4,2,35,9,"heh");//错误

show();//错误

public static void show(int... arr)

{

System.out.println(arr.length);

}

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

show(2,3,4,5,6,4,2,35,9,"heh");//错误

show();//对 ，长度为 0

@@静态导入(JDK1.5后)

StaticImport 静态导入。

当类名重名时，需要指定具体的包名。

当方法重名是，指定该方法 具体所属的对象或者类。

*/

import java.util.*;

import static java.util.Arrays.*;//导入的是Arrays这个类中的所有静态成员。

import static java.util.Collections.*;

当类名重名时，需要指定具体的包名。

当方法重名是，指定该方法 具体所属的对象或者类。下例=>

packa/Demo.class

packb/Demo.class

import packa.*;

import packb.*;

new Demo()//不明确

应该new packa.Demo();或new packb.Demo();

*/

import java.util.*;

import static java.lang.System.*;//导入了System类中所有静态成员。

import static java.util.Arrays.*;//导入的是Arrays这个类中的所有静态成员。

import static java.util.Collections.*;

class StaticImport //extends Object

{

public static void main(String[] args)

{

out.println("haha");

int[] arr = {3,1,5};

sort(arr);

int index = binarySearch(arr,1);

out.println(Arrays.toString(arr));//当方法重名时，指定该方法 具体所属的对象或者类。分清toString是谁的方法。

out.println("Index="+index);

ArrayList al = new ArrayList();

al.add(1);

al.add(3);

al.add(2);

out.println(al);

sort(al);

out.println(al);

}

}

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