一、组合子

1. 五种容器

存放单个数据（数据含义一致，不需要描述）

名称	用途
Array数组	固定大小
ArrayList	变化大小
HashSet	无序

存放键值对数据（数据含义各不相同，需要key对数据描述）

名称	用途
javaBean	固定大小
HashMap	变化大小

2. 遍历容器

名称	用途
for循环	知道大小
while循环	不知道大小
Iterator迭代器	无序容器需要先排序

3. 容器组合

容器可以组合使用，形成更丰富的容器

二、练习

1. 初级

容器练习类

容器	加值	取值	遍历	补充
定义1个数组（存姓名）	加1个值	取1个值	for循环遍历	for each
定义1个ArrayList（存地址）	加1个值	取1个值	for循环遍历
定义一个HashSet（存学号）	加1个值		迭代器（iterator）	while循环
定义一个JavaBean（存学生信息）	加1个值	取1个值	toString()
定义一个HashMap（存任意想到的数据）	加1个值	取1个值	迭代器（iterator）	while循环

package com.guoyasoft.selenium;

import java.net.Socket;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;

public class WuLing {
    public static void main(String[] args) {
        //程序：命令+命令要处理的数据
        //命令怎么封装，数据怎么存储
        int a=10;
        //容器：单个的数据（所有数据都是同一个含义），键值对的数据（key=value，要存的是value，key的作用是解释）
        
        //数组：单个值、大小固定、有顺序、可重复
        double[] scores=new double[8];
        scores[3]=60;
        scores[0]=20;
        
        //最小值、最大值、增量
        for(int i=0;i<scores.length;i++){
            System.out.println(scores[i]);
        }
        
        int i=0;
        while(i<scores.length){
            System.out.println(scores[i]);
            i++;
        }
        
        String[] girls={"刘艳","朱英英","贾苗"};
        
        //Arraylist：单个值、大小动态扩展、有序、可重复
        List<String> answerNames=new ArrayList<String>();
        answerNames.add("刘艳");
        
        answerNames.get(0);
        
        answerNames.add("朱英英");
        answerNames.get(1);
        
        for(int j=0;j<answerNames.size();j++){
            String s=answerNames.get(j);
            System.out.println(s);
        }
        
        for(String s:answerNames){
            System.out.println(s);
        }
        
        i=0;
        while(i<answerNames.size()){
            String s=answerNames.get(i);
            i++;
            System.out.println(s);
        }
        
        //HashSet:单个值、动态大小、无序、唯一（自动去重）
        Set<String> interviewStudents=new HashSet<String>();
        interviewStudents.add("wuling");
        interviewStudents.add("wuling");
        
        System.out.println(interviewStudents.size());
        
        //迭代器Iterator
        Iterator<String> iterator=interviewStudents.iterator();
        //知道个数的，用for循环，不知道个数的，用while循环
        while(iterator.hasNext()){
            String s=iterator.next();
            System.out.println(s);
        }
        
        
        //要存不同含义的多个数据，就需要给每个数据取一个描述含义的名字
        
        //多种不同含义的数据（键值对）、数量固定、类型固定、变量值不固定
        Student stu=new Student();
        stu.name="吴令";
        stu.score=99;
        
        System.out.println(stu.score);
        
        String studentStr=stu.toString();
        System.out.println(studentStr);
        
        List<Student> classList=new ArrayList<Student>();
        classList.add(stu);
        
        List<List<Student>> school=new ArrayList<List<Student>>();
        
        school.add(classList);
        
        
        //要存很多个数据，类型含义各不相同（key=value）、个数不定、无序
        Map<String,String> maps=new HashMap<String, String>();
        
        maps.put("name", "wuling");
        
        maps.get("name");
        
        maps.put("name", "guoya");
        
        maps.get("name");
        
        maps.put("student", "wuling");
        
        
        Iterator<Map.Entry<String, String>> iterator2=maps.entrySet().iterator();
        while(iterator2.hasNext()){
            Map.Entry<String, String> item=iterator2.next();
            String key=item.getKey();
            String value=item.getValue();
            System.out.println("key="+key+",value="+value);
        }
        
    }
}