初学集合，以及泛型
2016-09-26 13:57 宇航员舒克 阅读(208) 评论(0) 编辑 收藏 举报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);
}
}
