初学集合，以及泛型

package jiheke1;

public class person {
	private String name;
	private String age;
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public String getAge() {
		return age;
	}
	public void setAge(String age) {
		this.age = age;
	}
	public person(String name, String age) {
		super();
		this.name = name;
		this.age = age;
	}
	public person() {
		super();
		// TODO Auto-generated constructor stub
	}
	@Override
	public String toString() {
		return "person [name=" + name + ", age=" + age + "]";
	}
	
	
}





package jiheke1;

public class student extends person {

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

	public student(String name, String age) {
		super(name, age);
		// TODO Auto-generated constructor stub
	}

	
}




package jiheke1;
										//集合——List集合——常用集合 

// java中几种集合的层次关系：
//										——定义方式：List<泛型> 集合名称=new 实现类<>();或者：实现类List<泛型> 集合名称=new 实现类<>();
// 接口collection——接口List（列表）——ArrayList——特点：可变数组，有序，可以使用索引。可以添加重复数据
//										——用法：添加：add（对象），添加在集合的末尾
//												  add（索引，对象），在索引位置添加	
//											      获取：get（索引）			
//											      修改：set（索引，对象）	
//											      长度：size（）		
//											      移除：clear（）	
//											      查找：indexOF（对象）返回找到的首个对象的索引值，如果没找到返回-1。		
//											      存在：contains（对象）返回boolean值
//										   	      遍历：见本页第75行
//												  1.for（）
//											  	  2.foreach
//											  	  3.迭代器：获取：iterator<>迭代器名称=集合对象.iterator
//														 使用：while(hasNext()) 判断能否移动指针（即：判断判断是否存在下一次移动）{移动指针到一下一条数据上,同时获取数据}			
//														remove:移除数据

//			  			——LinkedList——以链表额形式保存数据，相对于ArrayList修改和删除快，随机存储速度慢，可变数组，有序，可以使用索引。可以添加重复数据

//	     	  ——接口set（集合）——内部调用treeMap的方法

// 接口Map（映射）——存放的是键值对的集合，其中key值不可以重复，value。可以重复无序不可以使用索引
//			 ——定义方式：Map<key的类型，value的类型> 集合名称=new 实现类<>();
//			 ——方法：
//			 ——添加put(key，value)如果k不存在就表示添加value，如果k存在，就覆盖旧的value
//			 ——获取：get(key)
//			 ——长度：size(key)
//			 ——移除:remove(key)  ——清除:calea(key)   ——存在：containskey(k)    ——存在：containsvalue(v)
//			 ——遍历：详情请见Mapjihe
import java.util.ArrayList; 
import java.util.Iterator;
import java.util.List;

public class ke1 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub

		//list集合——list实际是个一个接口,表示数据列表，可以理解为可变数组。
		//特点：有序，长度可变
		//<>表示泛型,里面承载着该集合的数据类型.
		//泛型  是在jdk1.5才加入的(没有泛型之前这么定义List集合：List ls=new ArrayList();——不能确定集合的数据类型)
		List ls1=new ArrayList();
		ls1.add(456);//只能使用object接受数据
		//需要用实现类进行实例化
		List<String> ls=new ArrayList<>();//ArrayList表示他的实现类，相当于实例化一样
		//或者这么写
		//ArrayList<String> ls=new ArrayList<>();
		//把数据放入集合
		ls.add("abc");//使用明确的数据类型接受数据。
		List<Integer> ls2=new ArrayList<>();
		ls2.add(123);
		
		
		
		
		//新建一个List集合
		List<person> lsp=new ArrayList<person>();
		
		//添加数据，插入不带索引号的add——相当于给集合按顺序写入
		person p3=new person("z","123");
		lsp.add(p3);
		//或者直接下面的写法;
		lsp.add(new person("A","20"));
		lsp.add(new person("C","21"));
		lsp.add(new person("B","22"));
		lsp.add(new person("D","23"));
		//插入数据，插入带索引号indest的写法
		lsp.add(1,new person("E","10"));//1位集合的索引号位置，1号位

		//添加子类的实例
		
		//获取长度
		System.out.println("size="+lsp.size());
		
		//查询数据，查找某个数据所在位置的索引
		//System.out.println(lsp.indexOf(new person("A","20"))); 错误方法
		System.out.println(lsp.indexOf(p3));
		
		//判断是否存在这个内容
		System.out.println(lsp.contains(p3));
		
		//遍历集合方式
		for(int i=0;i<lsp.size();i++)
		{
			System.out.println(i+"="+lsp.get(i));
		}
		//foreach
		for(person p:lsp)
		{
			System.out.println(p);
		}
		System.out.println("size="+lsp.size());
		//迭代器
		System.out.println("迭代器");
		//获取迭代器，可以看做是个指针。获取迭代器时，指针指向第一条记录的前面。集合的外面
		Iterator<person> it =lsp.iterator();
		//先判断能否移动，移动指针
		while (it.hasNext())
		{	//移动指针到一下一条数据上,同时获取数据
			person p=it.next();
			System.out.println(p);
			
			//移除数据
			if(p==p3)
			{
				it.remove();
			}
		}
		System.out.println("size="+lsp.size());
		//取数据
		person p0=lsp.get(0);
		//显示对象的所有属性的值
		System.out.println(p0.toString());//toString()方法，现在class内部（person）中重写toString()方法。toString()方法可以自动生成在源码菜单。
		//修改数据
		lsp.set(0, new person("F","30"));//0位集合的索引号位置，0号位
		System.out.println(lsp.get(0));
		//移除异常
		lsp.remove(1);
		System.out.println("size="+lsp.size());
		//清除数据
		lsp.clear();
		System.out.println("size="+lsp.size());
		//查询数据
		
		
		
	}

}



package jiheke1;
										//集合——set集合
import java.util.HashSet;

import java.util.Iterator;
import java.util.Set;
import java.util.TreeSet;

public class setjihe {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		//实现类HashSet
		//不能存放重复值的数据，没有顺序和索引。
		Set<person> s1=new HashSet<>();
		person p0=new person("A","20");
		//不能存放重复数据，但是存放了也不报错
		s1.add(p0);
		s1.add(p0);
		s1.add(p0);
		s1.add(null);//可以放空
		
		s1.add(new person("B","20"));
		s1.add(new person("D","20"));
		s1.add(new person("F","20"));
		s1.add(new person("G","20"));
		System.out.println("长度="+s1.size());
		//取,用遍历的方式取出，不能用get
		
		//remove移除
		s1.remove(p0);
		System.out.println("长度="+s1.size());
		//判断是否存在
		System.out.println(s1.contains(p0));
		//遍历
		for(person p:s1)
		{
			System.out.println(p);
		}
		System.out.println("长度"+s1.size());
		//Iterator迭代器
		Iterator<person> it=s1.iterator();
		//先判断能否移动，移动指针
		while(it.hasNext())
		{
			person p=it.next();
			System.out.println(p);
		}		
		
		
		
		
		
		//treeset——对内容可以按一定abcd的顺序排序，但是只支持可以排序的内容如abcd.....   
		//不可以方null
		TreeSet<String> ts=new TreeSet<>();
//		ts.add(null)  不可以方空
		ts.add("a");
		ts.add("A");
		ts.add("d");
		ts.add("f");
		ts.add("e");
		for(String a:ts)
		{
			System.out.println(a);
		}
		
	}
	
}



package jiheke1;
											//集合——映射Map	 
										//常用集合
import java.util.HashMap;  

import java.util.Map;
import java.util.TreeMap;

import javax.swing.plaf.synth.SynthScrollBarUI;

public class Mapjihe {

	public static void main(String[] args) {
		//HashMap
		Map<String, String>m1=new HashMap<>();
		//添加数据
		m1.put("0531", "济南");//k,v——此处k不可以重复,v可以重复
		m1.put("0532", "青岛");
		m1.put("0533", "淄博");
		m1.put("0531", "章丘");//如果key重复，新的value覆盖旧的value。
		m1.put("0530", "章丘");
																				
		//长度
		System.out.println("长度"+m1.size());
		//获取数据
		System.out.println(m1.get("0531"));//如果key重复，新的value覆盖旧的value。
		System.out.println(m1.get("0530"));	
		//移除
		m1.remove("0530");
		System.out.println(m1.get("0530"));
		//判断key的一个内容是否存在
		System.out.println(m1.containsKey("0533"));
		//判断value的一个内容是否存在
		System.out.println(m1.containsValue("淄博"));
		
		//遍历,通过遍历key顺便得到value，从而得到整个集合
		for(String k:m1.keySet())
		{
			System.out.println("key="+k+"value"+m1.get(k));
		}
		//key可以为空
		
		
		//TreeMap
		TreeMap<Integer, person> tm=new TreeMap<>();
		tm.put(100, new person("X","20"));
		tm.put(500, new person("S","20"));
		tm.put(10, new person("XD","20"));
		tm.put(300, new person("GF","20"));
		//遍历
		for(Integer a:tm.keySet())
		{
			System.out.println(a+m1.get(a));
		}
		//key不可以为空null，通过key对键值对进行排序的集合
	}
}

　　

package jiheke1;
                                                   //泛型
    
import java.util.ArrayList; 

import java.util.List;
public class fanxing {
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		//没有泛型——————类型不安全，使用时需要强制转型，使用不方便
		List ls=new ArrayList();
		ls.add(new person("x","20"));
		ls.add("zxc");
		ls.add(123);
		person p0=(person)ls.get(0);//在强制转成person型
		System.out.println(p0);
		
		
		//泛型——————类型安全，编译时能确定具体类型,不需要强制转换类型,使用方便
		List<person> lp=new ArrayList<>();
		lp.add(new person("y","20"));
		person p2=lp.get(0);
		System.out.println();
	}
	

}
                      




							//泛型课件
package jiheke1;

class fanxing2<T> {//泛型名称可以多个eg:<T,F,M>

//	//泛型————在类名和{之间写入<>，在<>中写泛型的名称用字母代替，如：3行
	//使用泛型
	public T getT(T t)
	{
		return t;
	}
	
	//泛型方法——在普通类中一样可以使用泛型方法
	public <E> void test(E e)//E泛型类型标识符
	{
		System.out.println(e);
	}
	
}



package jiheke1;

public class fanxing2test {

	public static void main(String[] args) {
		

		//泛型		
		fanxing2<person> f1=new fanxing2<>();
		person p1=f1.getT(new person("s","123"));
		System.out.println(p1);
		
		//调用test方法
		f1.test(123);
	}

}