集合

一、集合【理解即可】
    ① 概念：是一种工具类，也是一种容器，可以存储数量不等的对象。
② 位置：java.util包中
③ 学习过程中的内容：接口的特点、接口的功能方法、
                     接口的实现类、遍历集合中元素
二、Collection集合(父接口)
① 特点：存储object类型的对象。
② 方法：【重点】
   a. add(Object obj):往集合中添加元素。
   b. boolean contains(Object obj):判断对象obj是否在当前集合中存在，
                                   存在-true;不存在-false.
   c. boolean remove(Object obj):将对象obj从当前集合中移除。
   d. int size():获取集合中元素的个数
   
③ 实现类：没有直接的实现类
④ 遍历方式：详见子接口的实现类。
    
子接口：List集合【重点】
① 特点：存储Object对象，有序、有下标、元素允许重复。
下标范围：0~有效元素的个数-1 (0~size-1)
② 方法：
a. add(int index,Object obj):将对象obj插入到指定位置。
b. Object get(int index):根据下标获取指定集合元素的内容。
c. Object remove(int index):将指定下标元素从当前集合中删除，
                            并返回被删除的对象
d. Object set(int index,Object obj):将集合中指定元素的内容修改，
                                     并返回修改之前的元素内容。
③ 实现类：ArrayList（底端用数组实现）【开发重点】
   面试重点：不同实现的区别：
ArrayList:底层数组实现，查询快，增删慢。
          JDK1.2 版本，线程不安全，运行效率快。
Vector:底层数组实现，查询快，增删慢。
         JDK1.0 版本，线程安全，运行效率慢。
LinkedList:底层链表实现，查询效率低，增删快。
④ 遍历：
    a. 下标遍历：
for(int i=0;i<list.size();i++){
//根据下标获取对应的元素内容
System.out.println(list.get(i));
}
            b. forEach遍历：
语法：
for(数据类型 变量名:集合名字){
//
}
注意：数据类型取决于集合元素的数据类型
      如果集合加了泛型，数据类型取决于泛型的类型。
                        
        泛型集合：数据安全的集合。泛型强制约束集合中元素数据类型要一致。

1. 泛型类：【理解】
① class 类名<泛型标识1,泛型标识2>{
   }
   
   注意：泛型标识通常用T/E/K/V
            ② 泛型类创建对象时，指定泛型标识代表的具体数据类型：
类名<具体数据类型> 对象名=new 类名<具体的数据类型>();

注意：如果创建对象没有指定泛型标识代表的具体数据类型，默认的
      是Object类型。
2. 泛型接口：jdk5.0之后可以定义泛型接口。 【理解】
① 语法：
interface 接口名<泛型标识1,泛型标识2>{}
例如：
interface IA<T>{}
② 实现类：
第一种方式：
    class ClassA implements IA<具体数据类型>{}
第二种方式：
class ClassB<T> implements IA<T>{}
注意：在创建对象时，指定泛型类型。


Java提供操作集合的工具类：Collections.【了解】
  常用方法：
① public static void reverse(List list):倒置
② public static void shuffle(List list):随机显示
③ public static void sort(List list):排序

  注意：如果集合中存储的对象类型是自定义类型的对象，则需要
    让对应的类实现Comparable接口，从而实现compareTo方法。

    面试题目：区分Collection和Collections。
          
  Collection集合体系中的根接口。
  Collections操作集合的工具类。

eg:

package demo2017117;
public class Worker {
private String name;
private int age;
private double salary;
public Worker() {
super();
// TODO Auto-generated constructor stub
}

public Worker(String name, int age, double salary) {
super();
this.name = name;
this.age = age;
this.salary = salary;
}


public String getName() {
return name;
}


public void setName(String name) {
this.name = name;
}


public int getAge() {
return age;
}


public void setAge(int age) {
this.age = age;
}


public double getSalary() {
return salary;
}


public void setSalary(double salary) {
this.salary = salary;
}


public void work() {
System.out.println(name + "work");
}


@Override
public String toString() {
return "name=" + name + ", age=" + age + ", salary=" + salary;
}


@Override
public boolean equals(Object obj) {
if (this == obj)
return true;
if (obj == null)
return false;
if (getClass() != obj.getClass())
return false;
Worker other = (Worker) obj;
if (age != other.age)
return false;
if (name == null) {
if (other.name != null)
return false;
} else if (!name.equals(other.name))
return false;
if (Double.doubleToLongBits(salary) != Double
.doubleToLongBits(other.salary))
return false;
return true;
}
}
-----------------------创建的List集合类----------------------------
package demo2017117;
import java.util.ArrayList;
import java.util.List;
class Question_10 {
public static void main(String[] args) {
List<Worker> list = new ArrayList<Worker>();
list.add(new Worker("zhang3", 18, 3000));
list.add(new Worker("li4", 25, 3500));
list.add(new Worker("wang5", 22, 3200));
// 在li4之前插入一个工人"zhao6",24, 3300
list.add(1, new Worker("zhao6", 24, 3300));
// 删除wang5信息
list.remove(3);
// for遍历所有工人的信息
for (int i = 0; i < list.size(); i++) {
System.out.println(list.get(i));
}
// foreach遍历，对List所有的所有工人调用work方法
for (Worker worker : list) {
worker.work();
}
// eg:zhang3和li4信息是否相同
System.out.println(new Worker("zhang3", 18, 3000).equals(new Worker(
"li4", 25, 3500)));


}
}

子接口：Set集合【重点】
① 特点：存储Object类的对象，无序、无下标、元素的内容不允许重复。
         
② 方法：方法全部继承于父接口Collection

③ 实现类: HashSet【开发重点】
如果自定义类型的对象存储在HashSet集合中，为了保证元素的内容不重复，必须做到：
① 覆盖hashCode方法
目的：必须保证相同内容的对象返回相同的hashCode码值；
  为了提高效率，不同内容的对象尽量返回不同的hashCode码值。
覆盖原则：将所有的属性拼凑为一个int值作为返回值。
   例如：
   public int hashCode(){
return this.age+this.name.hashCode();
   }

   ② 覆盖equals方法 : 必须保证内容相同的对象结果返回true.
   
  |- SortedSet:是Set的子接口【了解】
① 特点：存储Object类型的对象，无序、无下标、元素内容不允许重复。
          可以根据元素内容自动排序。
     ② 实现类：TreeSet
自定义类型的对象存储在TreeSet集合中，如果compareTo的结果
返回值为0，则代表相同内容的元素，拒绝添加。

④ 遍历:forEach

eg：

package demo2017117;
public class Worker {
private String name;
private int age;
private double salary;


public Worker() {
super();
// TODO Auto-generated constructor stub
}


public Worker(String name, int age, double salary) {
super();
this.name = name;
this.age = age;
this.salary = salary;
}


public String getName() {
return name;
}


public void setName(String name) {
this.name = name;
}


public int getAge() {
return age;
}


public void setAge(int age) {
this.age = age;
}


public double getSalary() {
return salary;
}


public void setSalary(double salary) {
this.salary = salary;
}


public void work() {
System.out.println(name + "work");
}


@Override
public String toString() {
return "name=" + name + ", age=" + age + ", salary=" + salary;
}
     //equals方法用于比较两个对象的内容是否相等
public boolean equals(Object obj) {
if (this == obj)
return true;
if (obj == null)
return false;
if (getClass() != obj.getClass())
return false;
Worker other = (Worker) obj;
if(!(this.name.equals(other.name)&&this.age==other.age&&this.salary==other.salary)){
return false;
}
return true;
}
//hashCode方法获取对象的内存地址以整数返回值
public int hashCode(){
return name.hashCode()+age+(int)salary;
}
}
------------------------------------创建的Set集合类------------------------------------------
package demo2017117;
import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;
import java.util.Set;


class Question_10 {
public static void main(String[] args) {
Set<Worker> set = new HashSet<Worker>();
set.add(new Worker("zhang3", 18, 3000));
set.add(new Worker("li4", 25, 3500));
set.add(new Worker("li4", 25, 3500));
set.add(new Worker("wang5", 22, 3200));
set.add(new Worker("wang5", 22, 3200));
// 在插入一个工人"zhao6",24, 3300
set.add(new Worker("zhao6", 24, 3300));
// 删除wang5信息
set.remove(new Worker("wang5", 22, 3200));
// 所有工人的信息
for (Worker worker : set) {
System.out.println(worker);
}
// foreach遍历，对List所有的所有工人调用work方法
for (Worker worker : set) {
worker.work();
}
}
}

三、Map集合 【开发重点】
1. 特点：【重点】
① 存储任意的键值对(key-value)
② 键：无序、无下标、元素不允许重复(唯一性)
③ 值: 无序、无下标、元素允许重复
2. 方法：
① V put(K key,V value):将一个键值对存储在map集合中。如果键在map中
                        已经存在，则用新的数值覆盖旧值，将旧值作为返回值返回；
如果键在map不存在，值直接存储，返回null.【重点】
② V remove(K key):根据key删除map中的一个键值对，同时将删除值作为返回值返回。
③ V get(K key):根据键获取值。【开发重点】
④ boolean containsKey(K key):判断map集合中是否包含此键，包含-true;
                                                         不包含-false.
⑤ boolean containsValue(V value):判断map集合中是否包含此value,包含-true;
                                                                      不包含-false.
        ⑥ int size():获取键值对的个数。
3. 实现类：HashMap【开发应用重点】
① HashMap【重点】：JDK1.2 版本，线程不安全，运行效率快。
                     允许null作为key或是value.
② Hashtable:JDK1.0 版本，线程安全，运行效率慢。
                     不允许null作为key或是value.
    ③ Properties:是Hashtable的子类，键和值必须是String类型。
              作用：通常用于读取配置文件。
④ TreeMap:是SortedMap的实现类(SortedMap是Map的子接口)。
              作用：可以对键自动排序。

面试重点：写出 HashMap和Hashtable的区别？？？？

4. 遍历：
① 键遍历：【开发应用重点】
通过keySet方法获取map中所有的键：Set keySet();
Set<键的数据类型> ks=map.keySet();
for(键的数据类型 key:ks){
//通过键获取值的内容
值的数据类型 value=map.get();

}
② 值遍历：
通过values方法获取map中所有的值：Collection values();
Collection<值的数据类型> vs=map.values();
for(值的数据类型 value:vs){
//....
}
③ 键值对遍历：【开发应用重点】
通过entrySet方法获取map中所有的键值对：Set<Map.Entry<K,V>> entrySet();

Set<Map.Entry<K,V>> kvs=map.entrySet();
    for(Map.Entry<K,V> kv:kvs){
K key=kv.getKey();//获取键
V value=kv.getValue();//获取值

}

ej：

---------------------------------Worker类-----------------------------------
package demo2017119;
public class Worker {
private String name;
private int age;
private double salary;


public Worker() {
super();
// TODO Auto-generated constructor stub
}


public Worker(String name, int age, double salary) {
super();
this.name = name;
this.age = age;
this.salary = salary;
}


public String getName() {
return name;
}


public void setName(String name) {
this.name = name;
}


public int getAge() {
return age;
}


public void setAge(int age) {
this.age = age;
}


public double getSalary() {
return salary;
}


public void setSalary(double salary) {
this.salary = salary;
}


@Override
public String toString() {
return "name=" + name + ", age=" + age + ", salary=" + salary;
}


}
-----------------------------------Map集合----------------------------------
package demo2017119;


import java.util.HashMap;
import java.util.Map;
import java.util.Scanner;
import java.util.Set;


public class TestWorkerMap {
public static void main(String[] args) {
Map<Integer, Worker> map=new HashMap<Integer, Worker>();
map.put(new Integer(1), new Worker("张三",27,10000));
map.put(new Integer(2), new Worker("李四",23,7500));
map.put(new Integer(3), new Worker("王五",25,6000));
System.out.println("---------------遍历输出集合中所有的信息：id-工人信息------------------");
Set<Integer> set=map.keySet();
for(Integer in:set){                                       
System.out.println("id："+in+"--工人信息："+map.get(in));
}
System.out.println("------------------输入一个学号，查找是否存在，存在，则输出对应的姓名，否则输出-查无此人-！-------------------");
Scanner sc = new Scanner(System.in);
System.out.println("请输入您的id：");
int i = sc.nextInt();
/*boolean b = false;
for (Integer in:set) {
int ii=in;
if (i == ii) {
if (b = true) {
System.out.println("id："+ii+"--工人信息："+map.get(ii));
}
}
}
if (b != true) {
System.out.println("查无此人");
}*/
if(map.containsKey(i)){
System.out.println("id："+i+"--工人信息："+map.get(i));
}else{
System.out.println("查无此人");
}
System.out.println("--------------------统计工人的平均工资----------------------------");
Set<Integer> set1=map.keySet();
int sumSalary=0;
for(Integer in:set1){
sumSalary+=map.get(in).getSalary();            //获取总工资
}
double avg=sumSalary/map.size();
System.out.println("工人的平均工资："+avg);
System.out.println("--------------------输出id为偶数的员工信息----------------------------");
Set<Integer> set2=map.keySet();
for(Integer in:set2){ 
if(in%2==0){
System.out.println("id："+in+"--工人信息："+map.get(in));
}
}
System.out.println("--------------------输出id为偶数的员工信息----------------------------");
Set<Integer> set3=map.keySet();
for(Integer in:set3){ 
if(map.get(in).getSalary()>7000){
System.out.println("id："+in);
}
}
}
}

egege：

package demo20171120;


import java.util.HashMap;
import java.util.Map;
import java.util.Scanner;
import java.util.Set;
/**
 * 查询字符串中字符出现的次数
 * @author Mr fage
 * 2017-12-3下午5:48:06
 *
 */
public class Test2 {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
    System.out.println("请输入一个字符串：");
    String next = scanner.next();
    //将字符串转换成一个数组
    char[] charArray = next.toCharArray();
    //创建一个map集合
    Map<Character, Integer> map = new HashMap<Character,Integer>();
    for(char ch:charArray){
    //判断字符在集合是否出现
    if(map.containsKey(ch)){
    //出现过
    map.put(ch, map.get(ch)+1);
    }else{
    //未出现过
    map.put(ch, 1);
    }
   
    }
    Set<Character> v = map.keySet();
    for(Character ch:v){
    System.out.println(ch+"出现的次数："+map.get(ch));
   
    }
}
}