java基础之集合

集合类ArrayList

一、为什么会出现集合类？
java是面向对象编程的语言，他对事物的描述都是通过对象来实现的，为了方便对多个对象进行操作，就需要对多个对象进行存储，那么就需要一个容器类型的变量来存储。（StringBuilder的结果只能是一个字符串类型；数组的长度是固定的。）此时，java就提供了集合供我们使用。
二、集合的用法
ArrayList,E是一种特殊的数据类型，泛型。
在出现E的地方我们使用引用数据类型替换即可：ArrayList,Array
三、集合的方法
ArrayList();//构造方法
public boolean add(E e);//添加元素
public void add(int index,E e);//在指定的索引处添加一个元素
public E get(int index);//返回指定索引处的元素
public int size();//返回集合中元素的个数
public boolean remove(Object o);//删除指定元素，返回删除是否成功
public E remove(int index);//删除指定索引处的元素，返回删除的元素
public E set(int index,E e);//修改你指定索引处的元素，返回被修改的元素
四、集合的遍历之获取满足要求的元素
找到以“”张“”字开头的姓名输出到控制台上

    String[] str= {"张三","张毅","李四","五张"};
	ArrayList<String> array=new ArrayList<String>();
	for(int x=0;x<str.length;x++) {
		array.add(str[x]);//把数组中的元素添加到集合中
	}
	for(int i=0;i<array.size();i++) {//遍历集合
	  String s=array.get(i);
	  if(s.startsWith("张")) {
		  System.out.println(s);
	  }
	}

五、存储自定义对象并遍历

public class Student {
	private String name;
	private int age;	
public Student(String name, int age) {
		super();
		this.name = name;
		this.age = age;
	}
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 static void main(String[] args) {
	ArrayList<Student> array=new ArrayList<Student>();
	Student s1=new Student("张三",12);
	Student s2=new Student("李四",10);
	array.add(s1);
	array.add(s2);
	for(int i=0;i<array.size();i++) {//遍历集合
	Student s=array.get(i);
    System.out.println(s.getName()+":"+s.getAge());
	}
}
}

六、键盘录入数据存储并遍历

public static void main(String[] args) {
	ArrayList<Student> array=new ArrayList<Student>();
	addStudent(array);
	addStudent(array);
	for(int i=0;i<array.size();i++) {//遍历集合
	Student s=array.get(i);
    System.out.println(s.getName()+":"+s.getAge());
	}
}
public static void addStudent(ArrayList<Student> array) {
	Scanner sc=new Scanner(System.in);
	System.out.println("please input name");
	String name=sc.nextLine();
	System.out.println("please input age");
	int age=sc.nextInt();

	Student s=new Student();
	s.setName(name);
	s.setAge(age);
	array.add(s);
}

六、集合的体系结构
由于不同的数据结构（常见的数据结构：数组、链表、栈和队列），所以java为我们提供了不同的集合不同的集合功能都是相似的，不断地向上提取，将共性提取出来，这就是集合体系结构形成的原因。
七、Collection的用法
ArrayList----List------Collection(最高层)

Collection是所有单列集合的父接口，因此在Collection中定义了单列集合（List和Set）通用的一些方法，这些方法可用于操作所有的单列集合。

collect一些方法
bollean add(E e)	添加元素到容器，允许重复添加
void clear	清空集合
boolean contains(Object o)	是否包含某个元素
boolean isEmpty()	容器是否为空
boolean remove(Object o)	是否删除某个元素
int size()	返回元素个数
Object[] toArray	将集合转化成object类型的数组

public class CollectionTest {
public static void main(String[] args) {
	//创建集合对象
//	Collection c=new Collection();//collection是接口不能实例化
	Collection c=new ArrayList();
//  c.add("hello");
//	c.clear();
//	c.contains("hello");
//	c.isEmpty();
//	c.remove("hello");
	System.out.println(c.add("hello"));
	//集合的遍历方式
	//方式一、将集合转化成object类型的数组 ,遍历数组就可以了
	Object[] objs=c.toArray();
	for(int i=0;i<objs.length;i++) {
		System.out.println(objs[i]);
	}
	}
	}

集合的遍历方式：
方式一：toArray()，把集合转换成数组，然后遍历数组
方式二：iterator()，可以返回一个迭代器对象，可以通过迭代器对象来迭代集合
iterator():对collection进行迭代的迭代器。

Iterator:迭代器，可以用来遍历集合
E next();//返回下一个元素
boolean hasNext()判断是否有元素可以获取

//集合遍历的方式二
public class IteratorTest {
public static void main(String[] args) {
	Collection c=new ArrayList();
    c.add("hello");
    c.add("你好");
    //获取迭代器对象
    Iterator i=c.iterator();
    while(i.hasNext()) {
    	System.out.println(i.next());
    }
  }
  }

八、接口List的用法及其特点
包：import java.util.List;
父接口：Collection
注意： java.awt是list类

方法
void add(int index,E element)	在指定索引（从0开始）处添加元素
E get(int index)	根据索引获取元素并返回
E remove(int index)	根据索引删除指定元素并返回
E set(int dex,E element)	将指定索引处的元素替换为指定元素，并将原先的元素返回（修改，并返回元素）

List的常用子类	优缺点
ArrayList	底层结构是数组，查询快，增删慢
LinkedList	底层结构是链表 ，查询慢，增删快

那么如何选择不同的集合？
如果查询多，增删少，使用ArrayList
如果查询少，增删多，使用LinkedList
基本使用ArrayList最多。

LinkedList的特有功能

方法
void addFirst(E e)	将元素添加到索引为0的位置
void addLast(E e)	将元素添加到索引为size()-1的位置
E getFirst()	获取索引为0的元素
E getLast()	获取索引为size()-1的元素
E removeFirst()	删除第一个元素
E removeLast()	删除最后一个元素

......
LinkedList ll=new LinkedList();
list.add("java");
......

练习—返回指定列表中指定元素的索引位置

import java.util.ArrayList;
import java.util.List;
public class ListTest {
public static void main(String[] args) {
	List list=new ArrayList();
	list.add("hello");
	list.add("world");
	list.add("java");
	
	int index=index(list,"java0");
	System.out.println(index);

}
public static int index(List list,Object other) {
	for(int x=0;x<list.size();x++) {
		Object o=list.get(x);
		if(o.equals(other)) {
			return x;
		}
	}
	return -1;
}
}

九、Set接口的特点
1.无序，存储和读取的顺序有可能不一样
2.不允许数据的重复，他继承collection

Set是接口，用来定义一个集合，HashSet是Set的一个实现类

使用HashSet存储自定义对象并遍历
分析：HashSet的add()方法，首先会使用当前集合中的么一个元素和新添加的元素进行hash值比较，如果hash值一样，比较地址值或者使用equals方法进行比较，如果hash值不一样，直接添加新的元素。比较结果一样则不添加。

package test100;

import java.util.HashSet;

public class HashSetTest {
public static void main(String[] args) {
	HashSet<Student> hs=new HashSet<Student>();
	Student s1=new Student("张三",18);
	Student s2=new Student("李四",16);
	Student s3=new Student("李四",16);
	hs.add(s1);
	hs.add(s2);
	hs.add(s3);
	for (Student student : hs) {
		System.out.println(student);
	}
}
}
class Student{
	String name;
	int age;
	
	public Student(String name, int age) {
		this.name = name;
		this.age = age;
	}

	@Override
	public String toString() {
		return "Student [name=" + name + ", age=" + age + "]";
	}
	
	@Override
	public boolean equals(Object obj) {
		//向下转型，获取子类特有成员
		Student s=(Student)obj;
		if(this.age != s.age) {
			return false;
		}
		if(!this.name.equals(s.name)) {
			return false;
		}
		//默认返回true，说明俩个学生相等
		return true;
	}
	@Override
	public int hashCode() {
		// 重写hashcode，让他返回相同的值，就可以执行equals方法
		return 1;
	}
}

为了提高程序健壮性，优化代码
（hashcode()he equals()方法可以自动生成）

import java.util.HashSet;

public class HashSetTest {
public static void main(String[] args) {
	HashSet<Student> hs=new HashSet<Student>();
	Student s1=new Student("张三",18);
	Student s2=new Student("李四",16);
	Student s3=new Student("李四",16);
	hs.add(s1);
	hs.add(s2);
	hs.add(s3);
	for (Student student : hs) {
		System.out.println(student);
	}
}
}
class Student{
	String name;
	int age;
	
	public Student(String name, int age) {
		this.name = name;
		this.age = age;
	}

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

	@Override
	public int hashCode() {
		final int prime = 31;
		int result = 1;
		result = prime * result + age;
		result = prime * result + ((name == null) ? 0 : name.hashCode());
		return result;
	}

	@Override
	public boolean equals(Object obj) {
		if (this == obj)
			return true;
		if (obj == null)
			return false;
		if (getClass() != obj.getClass())
			return false;
		Student other = (Student) obj;
		if (age != other.age)
			return false;
		if (name == null) {
			if (other.name != null)
				return false;
		} else if (!name.equals(other.name))
			return false;
		return true;
	}		
}

十、Map<k,v>接口的概述
Map:将键映射到值的对象，一个映射不能包含重复的键，每个键最多映射一个值。
Map和Collection的区别：
Map是一个双列集合，常用于处理有对应关系的数据，key是不可以重复的，我们也称之为夫妻对集合。
Collection：是单列集合，Collection有不同的子体系，有的允许重复有索引有序，有的不允许重复而且无序，我们称之为单身汉集合。

Map的功能和测试：

V put(K key,V value)	映射功能（将key映射到value，如果key存在，则覆盖value，并将原来的value返回）
V get(Object key)	获取key对应的value
int size()	获取对应关系的个数
boolean containsKey(Object key)	判断指定的key是否存在
boolean containsValue(Object value)	判断指定的value是否存在
boolean isEmpty()	判断是否有对应关系
void clear()	清空所有的对应关系
V remove(Object key)	根据指定的key删除对应关系，并返回value
Set<Map.Entry<K,V>>entrySet()
Set keySet()	获取所有的key
Collection values()	获取所有的value

***

 - 关于Set<K> keySet()和 Collection<V> values() 的用法

***
public class MapTest {
public static void main(String[] args) {
	Map<String,String> map=new HashMap<String,String>();
	map.put("001","中航三");
	map.put("002","李四");
	map.put("003","王五");
	Set<String> keys=map.keySet();
	for (String string : keys) {
		System.out.println(string);
	}
	Collection<String> values=map.values();
	for (String string : values) {
		System.out.println(string);
	}
}
}

**

• Map的遍历方式

**

**方式一**
public class MapTest {
public static void main(String[] args) {
//1.创建map对象
	Map<String,String> map=new HashMap<String,String>();
//2.添加映射关系
	map.put("001","中航三");
	map.put("002","李四");
	map.put("003","王五");
	//召集所有的key
	Set<String> keys=map.keySet();
	//遍历所有的key 
	for (String key : keys) {
	//让每个key去找value
		String value=map.get(key);
		System.out.println(key+","+value);
	}
}
}