----HashMap特点：无序
建立集合： Map<String,String> map = new HashMap<String,String>
添加元素： map.put（"邓超","孙俪"） 返回上一个值（后面那个）
移除元素： map.clear（）； 移除所有元素
map.remove("K"); 移除键值K，附带移除对应的值V
判断: 是否包含 map.containskey("K");
是否为空 map.isEmpty（）;
长度： map.size（）; 判断集合MAP有多少对元素
获取： map.get（K） 返回K对应的V
遍历集合所有的键：
Set<类型> *** = map.keySet();
for(String **:***){
syso(**);
}
遍历集合所有的值:
Collection <类型> *** =map.values();
增强for
遍历所有的对： 第一种：
先遍历键K，在增强for中获取V：string * =map.get（key）；
syso(key +"-----" + value) ;
第二种：（理解）
// 获取所有键值对对象的集合
Set<Map.Entry<String, String>> set = map.entrySet();
// 遍历键值对对象的集合，得到每一个键值对对象
for (Map.Entry<String, String> me : set) {
// 根据键值对对象获取键和值
String key = me.getKey();
String value = me.getValue();
System.out.println(key + "---" + value);
----------LinkHashMap：有序（存储序列）唯一
----------TreeMap ： 自然排序 唯一 例题：treemapdemo
对于key是类对象，需要重写方法。
案例： public class TreeMapDemo2 {
public static void main(String[] args) {
// 创建集合对象
TreeMap<Student, String> tm = new TreeMap<Student, String>(new Comparator<Student>() {
public int compare(Student s1, Student s2) {
// 主要条件
int num = s1.getAge() - s2.getAge();
// 次要条件
int num2 = num == 0 ? s1.getName().compareTo(s2.getName()) : num;
return num2;
}
});
// 创建学生对象
Student s1 = new Student("潘安", 30);...............
-------------------------------------嵌套 hashmap-hashmap 例题：hashmapdemo2.java
hashmap-arraylist 自己写，简单
综合嵌套 看例题 hashmapdemo.java
----------------------------------- * 1:Hashtable和HashMap的区别?
* Hashtable:线程安全，效率低。不允许null键和null值
* HashMap:线程不安全，效率高。允许null键和null值
---------------------------------2:List,Set,Map等接口是否都继承子Map接口?
* List，Set不是继承自Map接口，它们继承自Collection接口
* Map接口本身就是一个顶层接口
-------------------------------------collections 集合
Collections.sort(list);排序 默认情况下是自然顺序。
Collections.binarySearch(list, 30)；二分查找
Collections.max(list)；最大值
Collections.reverse(list);反转
Collections.shuffle(list);随机置换
-------- 同时出现自然排序和比较器排序，以比较器为主--------
------------------- * 模拟斗地主洗牌和发牌
*
* 分析：
* A:创建一个牌盒
* B:装牌
* C:洗牌
* D:发牌
* E:看牌 例题：PokerDemo.java 地址http://download.csdn.net/detail/qq_34446485/9921208 其他同
Collection:是集合的顶层接口，它的子体系有重复的，有唯一的，有有序的，有无序的。(后面会慢慢的讲解)
*
* Collection的功能概述：
* 1：添加功能
* boolean add(Object obj):添加一个元素
* boolean addAll(Collection c):添加一个集合的元素
* 2:删除功能
* void clear():移除所有元素
* boolean remove(Object o):移除一个元素
* boolean removeAll(Collection c):移除一个集合的元素(是一个还是所有)
* 3:判断功能
* boolean contains(Object o)：判断集合中是否包含指定的元素
* boolean containsAll(Collection c)：判断集合中是否包含指定的集合元素(是一个还是所有)
* boolean isEmpty()：判断集合是否为空
* 4:获取功能
* Iterator<E> iterator()(重点)
* 5:长度功能
* int size():元素的个数
* 面试题：数组有没有length()方法呢?字符串有没有length()方法呢?集合有没有length()方法呢?
* 6:交集功能
* boolean retainAll(Collection c):两个集合都有的元素?思考元素去哪了，返回的boolean又是什么意思呢?
* 7：把集合转换为数组
* Object[] toArray()
--------------------------
// Collection c = new Collection(); //错误，因为接口不能实例化
Collection c = new ArrayList();
char[] chs =s.toCharArray(); toCharArray -把字符串转换成字符数组
16课时.
建立一个集合 （list集合）
-------------------------（arraylist） 泛型：在引用和重写后+类型<>，可避免强转，优化程序
ArrayList ** =new ArrayList();
add 添加
遍历 ：（用了泛型） 1. Iterator<String> *** =**.iterator<String>（）;
while（it.hasNext（））{
String * =***.next(); //存储的对象是什么，用什么接收。-双String-
System.out.println(*);
}
2.for(int x=0;x<array.size();x++){
String * =(String)array.get(x); //存储的对象是什么，用什么接收。-双String-
System.out.println(*);
}
ArrayList去除集合中字符串的重复值:
注：方法1中如果集合对象是一个类，则需在引用的类中重写equals方法，否则报错
1. // 创建新集合
ArrayList newArray = new ArrayList();
// 遍历旧集合,获取得到每一个元素
Iterator it = array.iterator();
while (it.hasNext()) {
String s = (String) it.next();
// 拿这个元素到新集合去找，看有没有
if (!newArray.contains(s)) {
newArray.add(s);
}
}
2.// 由选择排序思想引入，我们就可以通过这种思想做这个题目
// 拿0索引的依次和后面的比较，有就把后的干掉
// 同理，拿1索引...
for (int x = 0; x < array.size() - 1; x++) {
for (int y = x + 1; y < array.size(); y++) {
if (array.get(x).equals(array.get(y))) {
array.remove(y);
y--;
}
}
}
-----------------------------（vector） add get Iterator 等对应，可替换
// 创建集合对象
Vector v = new Vector();
// 添加功能
v.addElement("hello");
v.addElement("world");
v.addElement("java");
遍历：1.for (int x = 0; x < v.size(); x++) {
String s = (String) v.elementAt(x);
System.out.println(s);
}
2.Enumeration en = v.elements(); // 返回的是实现类的对象
while (en.hasMoreElements()) {
String s = (String) en.nextElement();
System.out.println(s);
}
}
--------------------------（LinkedList） remove移除的元素会被返回
LinkedList link = new LinkedList(); // 创建集合对象
link.addFirst("javaee");
link.addLast("android");
System.out.println("getFirst:" + link.getFirst());
System.out.println("getLast:" + link.getLast());
System.out.println("removeFirst:" + link.removeFirst());
System.out.println("removeLast:" + link.removeLast());
遍历通用
-----------------------------------------------------------------------------------------
泛型：
1.用在类 （在实现的时候需要每次注明类型）
public class ObjectTool<T> {
private T obj;
用法： ObjectTool<String> ot = new ObjectTool<String>();
ot.setObj(new String("林青霞"));
String s = ot.getObj();
System.out.println("姓名是：" + s);
ObjectTool<Integer> ot2 = new ObjectTool<Integer>();
ot2.setObj(new Integer(27));
Integer i = ot2.getObj();
System.out.println("年龄是：" + i);
2.用在方法上 （无论什么类型直接引用，无需注明）
public <T> void show(T t) {
System.out.println(t);
}
用法：ObjectTool ot = new ObjectTool();
ot.show("hello");
ot.show(100);
ot.show(true);
3.用在接口上
写接口 public interface Inter<T> {
public abstract void show(T t);
}
写类
--第一种情况：已经知道该是什么类型的了
//public class InterImpl implements Inter<String> {
//public void show(String t) {
//System.out.println(t);
//}
// }
--第二种情况：还不知道是什么类型的
public class InterImpl<T> implements Inter<T> {
public void show(T t) {
System.out.println(t);
}
}
测试
public static void main(String[] args) {
// 第一种情况的测试 <>与引用类一致
// Inter<String> i = new InterImpl();
// i.show("hello");
// // 第二种情况的测试
Inter<String> i = new InterImpl<String>();
i.show("hello");
Inter<Integer> ii = new InterImpl<Integer>();
ii.show(100);
}
----------- 泛型高级(通配符)
// 泛型如果明确的写的时候，前后必须一致（//后的是报错的）
Collection<Object> c1 = new ArrayList<Object>();
// Collection<Object> c2 = new ArrayList<Animal>();
// Collection<Object> c3 = new ArrayList<Dog>();
// Collection<Object> c4 = new ArrayList<Cat>();
// ?表示任意的类型都是可以的
Collection<?> c5 = new ArrayList<Object>();
Collection<?> c6 = new ArrayList<Animal>();
Collection<?> c7 = new ArrayList<Dog>();
Collection<?> c8 = new ArrayList<Cat>();
// ? extends E:向下限定，E及其子类
// Collection<? extends Animal> c9 = new ArrayList<Object>();
Collection<? extends Animal> c10 = new ArrayList<Animal>();
Collection<? extends Animal> c11 = new ArrayList<Dog>();
Collection<? extends Animal> c12 = new ArrayList<Cat>();
// ? super E:向上限定，E极其父类
Collection<? super Animal> c13 = new ArrayList<Object>();
Collection<? super Animal> c14 = new ArrayList<Animal>();
// Collection<? super Animal> c15 = new ArrayList<Dog>();
// Collection<? super Animal> c16 = new ArrayList<Cat>();
}
}
class Animal {
}
class Dog extends Animal {
}
class Cat extends Animal {
}
jdk5新特性
----------------------------------------------------------------------------------------
-------------------------------------增强for：
for（元素类型 *：数组或集合）{
system.out.println（*）；
}
//用来给数组或者集合遍历，及其简单，但是对于数组或者集合不能为空，（null ），
解决办法，加一个if判断。 if（数组 ！=null）{} 。一般用来替代集合迭代器
------------------------------------------------------------------------------------
---------------------------静态导入（一般不用，非静态方法不能用，错误多）
格式：import static 包名.类名.方法名.
用的时候可直接引用方法
------------------------------------------------------------------------------------
-------------------可变参数
格式： 修饰符 +返回值类型+方法名+（数据类型...+变量名）{}
比如 public static int sum （int...a）{
int s=0;
for(int x:a){
s +=x; //a相当于一个数组，遍历后自家，用于不知道多少个数
} //的变量相加（左边的方法）
return s;
}
-----------------------------------------------------------------------------------------
--------------------数组转集合-------这种转化的集合不能增删，但是能改
保留了数组的特性：长度不变
import java.util.Arrays；
List<String> list = Arrays.asList(数组名字或者直接多个元素)
-----------------------------------------------------------------------------------------
------------------嵌套集合
// 创建大集合
ArrayList<ArrayList<Student>> bigArrayList =new ArrayList<ArrayList<Student>>();
// 分别创建小集合
ArrayList<Student> firstArrayList = new ArrayList<Student>();
// 遍历嵌套集合
for (ArrayList<Student> array : bigArrayList) {
for (Student s : array) {
System.out.println(s.getName() + "---" + s.getAge());
}
}
----------------------------------------------------------------------------------------
-----------------例题
import java.util.ArrayList;
import java.util.Random;
* 获取10个1-20之间的随机数，要求不能重复
*
* 用数组实现，但是数组的长度是固定的，长度不好确定。
* 所以我们使用集合实现。
*
// random：该值大于等于0.0且小于1.0，即取值范围是[0.0,1.0)的左闭右开区间
// contains：包含就返回true equals：相等返回true
* 分析：
* A:创建产生随机数的对象
* B:创建一个存储随机数的集合。
* C:定义一个统计变量。从0开始。
* D:判断统计遍历是否小于10
* 是:先产生一个随机数，判断该随机数在集合中是否存在。
* 如果不存在:就添加，统计变量++。
* 如果存在:就不搭理它。
* 否：不搭理它
* E:遍历集合
*/
public class RandomDemo {
public static void main(String[] args) {
// 创建产生随机数的对象
Random r = new Random();
// 创建一个存储随机数的集合。
ArrayList<Integer> array = new ArrayList<Integer>();
// 定义一个统计变量。从0开始。
int count = 0;
// 判断统计遍历是否小于10
while (count < 10) {
//先产生一个随机数
int number = r.nextInt(20) + 1;
//判断该随机数在集合中是否存在。
if(!array.contains(number)){
//如果不存在:就添加，统计变量++。
array.add(number);
count++;
}
}
//遍历集合
for(Integer i : array){
System.out.println(i);
}
}
}
----------------------------------------------------------------------------------------
-----------------例题
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Scanner;
/*
* 键盘录入多个数据，以0结束，要求在控制台输出这多个数据中的最大值
*
* 分析：
* A:创建键盘录入数据对象
* B:键盘录入多个数据,我们不知道多少个，所以用集合存储
* C:以0结束,这个简单，只要键盘录入的数据是0，我就不继续录入数据了
* D:把集合转成数组
* E:对数组排序
* F:获取该数组中的最大索引的值
*/
public class ArrayListDemo {
public static void main(String[] args) {
// 创建键盘录入数据对象
Scanner sc = new Scanner(System.in);
// 键盘录入多个数据,我们不知道多少个，所以用集合存储
ArrayList<Integer> array = new ArrayList<Integer>();
// 以0结束,这个简单，只要键盘录入的数据是0，我就不继续录入数据了
while (true) {
System.out.println("请输入数据：");
int number = sc.nextInt();
if (number != 0) {
array.add(number);
} else {
break;
}
}
// 把集合转成数组
// public <T> T[] toArray(T[] a)
Integer[] i = new Integer[array.size()];
array.toArray(i);
// 对数组排序
// public static void sort(Object[] a)
Arrays.sort(i);
// 获取该数组中的最大索引的值
System.out.println("数组是：" + arrayToString(i) + "最大值是:"
+ i[i.length - 1]);
}
public static String arrayToString(Integer[] i) {
StringBuilder sb = new StringBuilder();
sb.append("[");
for (int x = 0; x < i.length; x++) {
if (x == i.length - 1) {
sb.append(i[x]);
} else {
sb.append(i[x]).append(", ");
}
}
sb.append("]");
return sb.toString();
}
}
--------------------------------------------------------------------------------------
set集合
list集合 ：有序，可重复
set集合：无序，唯一
----------------------HashSet （每次迭代的顺序都有可能变化）
创建集合： HashSet<类型> set = new HashSet<类型>（）；
其余和list集合一样
---------注意： 当set对象是一个类，而不是普通int等类型，需要在类中重写哈希值和equals方法，ALT+ SHIFT+S （自动生成） 。否则会出现重复元素
----------------------LinkedHashSet集合： 元素顺序迭代不变，怎么存储怎么遍历
LinkedHashSet<> ** = new LinkedHashSet<>();
----------------------TreeSet集合： 根据自然排序或者 比较器排序
TreeSet<> * = new TreeSet<>();
如果存储元素是int类型，默认采用自然排序，但是当元素类型为引用类
则需要在类里导入接口----implements Comparable<类名（类型）>
然后在末尾重写方法 （返回值<0从大到小，=0只导入第一个元素,>0从小到大）
---public int compareTo(student s) {
// 主要条件 姓名的长度
int num = this.name.length() - s.name.length();
// 姓名的长度相同，不代表姓名的内容相同
int num2 = num == 0 ? this.name.compareTo(s.name) : num;
// 姓名的长度和内容相同，不代表年龄相同，所以还得继续判断年龄
int num3 = num2 == 0 ? this.age - s.age : num2;
return num3;
}