------- android培训、java培训、期待与您交流! ----------
02 集合 共性方法
import java.util.*;
/*
1.add方法的参数类型是Object,以便于接受任意类型对象
2.方法中存储的都是对象的引用或者地址
什么是迭代器呢?
其实就是集合的取出元素的方式
*/
class CollectionDemo
{
public static void main(String[] args)
{
//method_2();
//base_method();
get_method();
}
public static void sop(Object obj)
{
System.out.println(obj);
}
public static void base_method()
{
//创建一个集合容器,使用Collection接口的子类:ArrayList
ArrayList al = new ArrayList();
//1,添加元素
al.add("java01");//add()参数类型是Object类型的,因为可以是任意对象
al.add("java02");
al.add("java03");
al.add(4);
sop("原集合:"+al);
//2.获取个数,集合长度size();
sop("size="+al.size());
//3.删除元素
al.remove("java02");
sop("改变后的集合:"+al);
al.clear();//清空集合
sop(al);
//4.判断集合是否为空
sop("判断元素是否存在"+al.contains("java01"));
sop("判断集合是否为空"+al.isEmpty());
}
public static void method_2()
{
ArrayList al1 = new ArrayList();
al1.add("java01");//add()参数类型是Object类型的,因为可以是任意对象
al1.add("java02");
al1.add("java03");
ArrayList al2 = new ArrayList();
al2.add("java05");//add()参数类型是Object类型的,因为可以是任意对象
al2.add("java06");
al2.add("java04");
al2.retainAll(al1);//取交集,al1中只会保留和al2中相同的元素
sop("al1:"+al1);
sop("al2:"+al2);
}
public static void get_method()
{
ArrayList al = new ArrayList();
al.add("java01");
al.add("java02");
al.add("java03");
al.add(4);
/*Iterator it = al.iterator();//返回的是Iterator接口类型的对象,Iterator是一个集合的内部类
while (it.hasNext())
{
sop(it.next());
}*/
for (Iterator it = al.iterator();it.hasNext();)//这样写不用在迭代结束后还保留it对象,因为it是for循环的一个内部变量,便于内存管理
{
sop(it.next());
}
}
}
14.04 集合框架 List集合共性方法
/*
Collction
--List:元素是有序的,元素可以重复,因为该集合体系有索引
--ArrayLitst:底层是数组结构。特点:线程不同步。默认长度是10,扩展加5 查询快,增删慢
--LinkedList:底层是链表结构 查询慢,增删快
--Vector:1.0版本的东西,1.2版本以后才有集合框架。特点:线程同步,被ArrayList替代了。默认是10,扩展加10
一般用ArrayList,速度比Vector快很多
--Set:元素无序的,元素不可以重复
List:
特有方法,凡是可以操作角标的方法都是该体系特有的方法
增
add(int index, E element);
addAll(index,Collection);
删
remove(index);
改
set(index,element);
查
get(index);
subList(from,to);
listIterator();
List集合特有的迭代器,ListIterator是Iterator的子接口
在迭代时,不可以通过集合对象的方法操作集合中的元素
因为会发生ConcurrentModificationException并发操作异常
所以,在迭代时,只能用迭代器的方法操作元素,可以Iterator方法是有限的
只能对元素进行判断,取出和删除的操作
如果想要其他的操作如添加,修改等,就需要使用其子接口ListIterator
该接口只能通过List集合listIterator方法 获取
*/
import java.util.*;
class ListDemo
{
public static void main(String[] args)
{
//method();
//演示列表迭代器
ArrayList al = new ArrayList();
//添加元素
al.add("java01");
al.add("java02");
al.add("java03");
al.add(4);
sop("原集合是:"+al);
ListIterator li = al.listIterator();
while (li.hasNext())
{
Object obj = li.next();
if (obj.equals("java02"))
li.set("java006");
if(obj.equals("java03"))
li.add("new");
sop("obj="+obj);
}
sop(li.hasNext());
sop(li.hasPrevious());
sop("改变后的集合:"+al);
//在迭代过程中,准备添加或者删除元素
/*Iterator it = al.iterator();
while (it.hasNext())
{
Object obj = it.next();
if (obj.equals("java02"))
//al.add("java008");//这步操作可能会引起并发访问异常,因为al有两种操作方式,容易产生安全隐患
it.remove();
sop("obj="+obj);//迭代过程中即使删除的元素也会被obj引用,所以也能打印出来,而且Iterator只有三个方法,有局限性
}*/
}
public static void method()
{
ArrayList al = new ArrayList();
//添加元素
al.add("java01");
al.add("java02");
al.add("java03");
al.add(4);
sop("原集合是:"+al);
//在指定位置添加元素
al.add(1,"java09");
//删除指定位置的元素
//all.remove(2);
//修改元素
al.set(2,"java007");
//通过角标获取元素
//sop("get(1):"+al.get(1));
//sop(al);
//获取所有元素
for (int x = 0;x < al.size();x++)
{
sop("al("+x+")="+al.get(x));
}
Iterator it = al.iterator();
while (it.hasNext())
{
sop(it.next());
}
//通过indexOf获取对象的位置
sop("index="+al.indexOf("java09"));
List sub = al.subList(1,4);
sop("sub="+sub);
}
public static void sop(Object obj)
{
System.out.println(obj);
}
}
14.07 集合框架 Vector中的枚举
import java.util.*;
/*
枚举就是Vector特有的取出方式
发现枚举和迭代器很像
其实枚举和迭代是一样的
因为枚举的名称和方法都过长
所以被迭代器取代了
*/
class VectorDemo
{
public static void main(String[] args)
{
Vector v = new Vector();
v.add("java01");
v.add("java02");
v.add("java03");
v.add("java04");
Enumeration en = v.elements();
while (en.hasMoreElements())
{
System.out.println(en.nextElement());
}
}
}
14.08 集合框架 LinkedList
import java.util.*;
/*
LinkedList:特有方法(面试比较多)
addFist();
addLast();
getFirst();
getLast();
获取并删除
removeFirst();
removeFirst();
删除并获取
JDK1.6以后出现了替代方法:
offerFirst();
offerFirst();
peekFirst();
peekLast();如果没有元素,则返回null
pollFirst();
pollLast();如果没有元素,则返回null
*
/
class LinkedDemo
{
public static void main(String[] args)
{
LinkedList link = new LinkedList();
link.addFirst("java01");
link.addFirst("java02");
link.addFirst("java03");
link.addFirst("java04");
sop(link);
sop(link.getFirst());
sop(link.getLast());
sop(link.size());
sop(link.removeFirst());
sop(link.size());
while (!link.isEmpty())
{
sop(link.removeFirst());
}
}
public static void sop(Object obj)
{
System.out.println(obj);
}
}
14.09 LinkedList练习
/*
使用LinkedList模拟一个堆栈或者队列数据结构
LIFOFIFO
堆栈:先进后出
队列:先进先出 Queue
*/
import java.util.*;
class Queue
{
private LinkedList link;
Queue()
{
link = new LinkedList();
}
public void myAdd(Object obj)
{
link.addFirst(obj );
}
public Object myGet()
{
return link.removeFirst();
}
public boolean isNull()
{
return link.isEmpty();
}
}
class LinkedListTest
{
public static void main(String[] args)
{
Queue q = new Queue();
q.myAdd("java01");
q.myAdd("java02");
q.myAdd("java03");
q.myAdd("java04");
while (!q.isNull())
{
System.out.println(q.myGet());
}
}
}
14.10 集合框架 ArrayList练习
/*
需求:
去除ArrayList中重复的元素
*/
import java.util.*;
class ArrayListTest
{
public static void main(String[] args)
{
ArrayList al = new ArrayList();
al.add("java01");
al.add("java02");
al.add("java01");
al.add("java02");
al.add("java01");
al.add("java03");
sop("原容器:"+al);
al = singleElements(al);
sop("有去重功能的新容器:"+al);
}
public static ArrayList singleElements(ArrayList al)
{
ArrayList newal = new ArrayList();
Iterator it = al.iterator();
while (it.hasNext())
{
Object obj = it.next();
if (!newal.contains(obj))//it.next()每次由hasNext判断之后都得让newal再判断,如果不赋值成临时变量,那么会发生只判断一个元素的情况
newal.add(obj);
}
return newal;
}
public static void sop(Object obj)
{
System.out.println(obj);
}
}
1502 集合框架 treeset存储自定义对象
/*
Set:无序,不可以重复元素
--HashSet:数据结构是哈希表,线程是非同步的
保证元素唯一性的原理,判断元素的hashCode值是否相同
如果相同,还会继续判断元素的equals方法,是否为true
--TreeSet:可以对Set集合中的元素进行排序
底层数据结构是二叉树
1,保证元素唯一性的依据compareTo方法return 0 。
2,当元素不具备比较性时,或者具备的比较性不是所需要的
这时就需要让集合自身具备比较性
在集合初始化时,就有了比较方式
需求;
往TreeSet集合中存储自定义对象学生
想按照学生的年龄进行排序
记住:排序时,当主要条件相同时,一定判断次要条件
*/
import java.util.*;
class TreeSetDemo
{
public static void main(String[] args)
{
TreeSet ts = new TreeSet();
ts.add(new Student("lisi02",22));
ts.add(new Student("lisi007",20));
ts.add(new Student("lisi09",19));
ts.add(new Student("lisi08",19));
Iterator it = ts.iterator();
while (it.hasNext())
{
Student stu = (Student)it.next();
System.out.println(stu.getName()+"::"+stu.getAge());
}
}
}
class Student implements Comparable//该接口强制让学生具备比较性
{
private String name;
private int age;
Student(String name,int age)
{
this.name = name;
this.age = age;
}
public int compareTo(Object obj)
{
if (!(obj instanceof Student))
throw new RuntimeException("不是学生对象");
Student s = (Student)obj;
System.out.println(this.name+"::compare to::"+s.name);
if (this.age > s.age)
return 1;
if(this.age == s.age)
{
return this.name.compareTo(s.name);
};
return -1;
}
public String getName()
{
return name;
}
public int getAge()
{
return age;
}
}
import java.util.*;
/*
当元素自身不具备比较性,或者具备的比较性不是所需要的
这时需要让容器自身具备比较性
定义了比较器,将比较器做为参数传递给TreeSet集合的构造函数
当两种顺序都存在时,以比较器为主
定义一个类,实现Comparator接口,覆盖compare方法
*/
class TreeSetDemo2
{
public static void main(String[] args)
{
TreeSet ts = new TreeSet(new MyCompare());
ts.add(new Student("lisi02",22));
ts.add(new Student("lisi007",20));
ts.add(new Student("lisi09",19));
ts.add(new Student("lisi08",19));
ts.add(new Student("lisi007",21));
Iterator it = ts.iterator();
while (it.hasNext())
{
Student stu = (Student)it.next();
System.out.println(stu.getName()+"::"+stu.getAge());
}
}
}
class Student implements Comparable//该接口强制让学生具备比较性
{
private String name;
private int age;
Student(String name,int age)
{
this.name = name;
this.age = age;
}
public int compareTo(Object obj)
{
if (!(obj instanceof Student))
throw new RuntimeException("不是学生对象");
Student s = (Student)obj;
System.out.println(this.name+"::compare to::"+s.name);
if (this.age > s.age)
return 1;
if(this.age == s.age)
{
return this.name.compareTo(s.name);
};
return -1;
}
public String getName()
{
return name;
}
public int getAge()
{
return age;
}
}
class MyCompare implements Comparator
{
public int compare(Object o1,Object o2)
{
Student s1 = (Student)o1;
Student s2 = (Student)o2;
int num = s1.getName().compareTo(s2.getName());
if (num == 0)
{
if (s1.getAge() > s2.getAge())
return 1;
if (s1.getAge() == s2.getAge())
return 0;
return -1;
}
return num;
}
}
1504 集合框架--实现Comparator方式排序
import java.util.*;
/*
当元素自身不具备比较性,或者具备的比较性不是所需要的
这时需要让容器自身具备比较性
定义了比较器,将比较器做为参数传递给TreeSet集合的构造函数
当两种顺序都存在时,以比较器为主
定义一个类,实现Comparator接口,覆盖compare方法
*/
class TreeSetDemo2
{
public static void main(String[] args)
{
TreeSet ts = new TreeSet(new MyCompare());
ts.add(new Student("lisi02",22));
ts.add(new Student("lisi007",20));
ts.add(new Student("lisi09",19));
ts.add(new Student("lisi08",19));
ts.add(new Student("lisi007",21));
Iterator it = ts.iterator();
while (it.hasNext())
{
Student stu = (Student)it.next();
System.out.println(stu.getName()+"::"+stu.getAge());
}
}
}
class Student implements Comparable//该接口强制让学生具备比较性
{
private String name;
private int age;
Student(String name,int age)
{
this.name = name;
this.age = age;
}
public int compareTo(Object obj)
{
if (!(obj instanceof Student))
throw new RuntimeException("不是学生对象");
Student s = (Student)obj;
System.out.println(this.name+"::compare to::"+s.name);
if (this.age > s.age)
return 1;
if(this.age == s.age)
{
return this.name.compareTo(s.name);
};
return -1;
}
public String getName()
{
return name;
}
public int getAge()
{
return age;
}
}
class MyCompare implements Comparator
{
public int compare(Object o1,Object o2)
{
Student s1 = (Student)o1;
Student s2 = (Student)o2;
int num = s1.getName().compareTo(s2.getName());
if (num == 0)
{
reture new Integer(s1.getAge()).compareTo(new integer(s2.getAge()));
/*if (s1.getAge() > s2.getAge())
return 1;
if (s1.getAge() == s2.getAge())
return 0;
return -1;*/
}
return num;
}
}
1505TreeSet练习
/*
练习:按照字符串长度排序
字符串本身具备比较性,但是他的比较方式不是所需要的
这时就只能使用比较器
*
/
import java.util.*;
class TreeSetTest
{
public static void main(String[] args)
{
TreeSet ts = new TreeSet(new StrLenComparator());
ts.add("abcd");
ts.add("cc");
ts.add("cba");
ts.add("aaa");
ts.add("z");
ts.add("hahaha");
Iterator it = ts.iterator();
while (it.hasNext())
{
System.out.println(it.next());
}
}
}
class StrLenComparator implements Comparator
{
public int compare(Object o1,Object o2)
{
String s1 = (String)o1;
String s2 = (String)o2;
/*if (s1.length() > s2.length())
return 1;
if(s1.length() == s2.length())
return 0;
return -1;
*/
int num = new Integer(s1.length()).compareTo(new Integer(s2.length()));
if (num == 0)
{
return s1.compareTo(s2);
}
return num;
}
}
1506
import java.util.*;
/*
泛型:JDK1.5版本以后出现新特性,用于解决安全问题,是一个类型2012-10-21安全机制
好处:
1。将运行时期出现问题ClasscastException转移到了编译时期,提高安全性
2.避免了强制转换
*/
class GenericDemo
{
public static void main(String[] args)
{
ArrayList<String> al = new ArrayList<String>();//定义的时候就定义集合类型,用尖括号
al.add("abc001");
al.add("abc088");
al.add("abcd1");
//al.add(4);//这个添加暴露了安全问题,类型转换异常
Iterator<String> it = al.iterator();
while (it.hasNext())
{
String s = it.next();
System.out.println(s+":"+s.length());
}
}
}