一.集合的组成及概念
为什么出现集合类？
面向对象语言对事物的体现都是以对象的形式，所以为了方便对多个对象的操作，就对对象进行存储，集合就是存储对象最常用的一种方式。
数组和集合类同时容器，有何不同？
数组虽然也可以存储对象，但是长度固定，集合长度是可变的。
数组中可以存储基本数据类型，集合只能存储对象。
集合类的特点
集合只用于存储对象，集合长度是可变的，集合可以存储不同类型的对象。
二.Collection
1.collection //2
（1）.collection的组成 //3
List:元素是有序的，元素可以重复。因为该集合体系有索引。
set:元素是无序，元素不可以重复。
（2）演示collection的共性方法 //3
共性方法
1.add
2.获取个数。集合长度。
sop("size:"+a1.size());
打印集合
sop(a1); //这样就可以打印集合中所有元素
3.删除元素
清空集合
a1.clear();
4.判断元素(是否包含其他元素，或者是否为空)
sop("java03是否存在："+a1.contains("java03"));
sop("集合是否为空？"+a1.isEmpty());
（3）迭代器（Iterator）
什么是迭代器呢？
a1.remove("java02");
sop(a1);
其实就是集合的取出元素的方式。
可以这么理解 容器就是一个大罐子 里面的对象就是罐子里的布娃娃
迭代器就是抓娃娃的爪子 要抓娃娃爪子要移动 松开 抓紧之类的各种状态
(4)代码实例
import java.util.*;
class CollectionDemoText
{
public static void main(String[] args)
{
method_get_size();
}
public static void sop(Object obj)
{
System.out.println(obj);
}
public static void method_get_size()
{
ArrayList a11 = new ArrayList();
a11.add("java01");
a11.add("java02");
a11.add("java03");
a11.add("java04");
sop(a11);//打印所有元素
ArrayList a12 = new ArrayList();
a12.add("java011");
a12.add("java021");
a12.add("java031");
a12.add("java041");
a12.add("java01");
sop(a12);//打印所有元素
//演示集合中是否为空，是否包含某一元素操作
sop("a12是否为空--"+a12.isEmpty());
sop("a12是否包含java01--"+a12.contains("java01"));
sop("a12是否包含java03--"+a12.contains("java03"));
//演示通过迭代器获取集合元素操作
Iterator t1 = a11.iterator();
sop("下面获取集合中的元素");
while(t1.hasNext())
{
sop(t1.next());
}
//演示获取集合长度操作
sop("下面打印集合的长度");
sop("集合长度是----"+a11.size());
//演示获取相同元素操作
//sop("下面是两个集合共有的元素");
//a11.retainAll(a12);
//sop(a11);
//演示删除操作
sop("下面删除元素");
a11.remove("java01");
sop(a11);
//演示清空操作
sop("下面清空集合");
sop("集合a12"+a12);
sop("开始清空");
a12.clear();
sop("集合a12"+a12);
}
}
注意：！！！！！
retainall返回的是true(有相同)，false(无相同)
然后改变了调用集合的元素，只保留了相同的元素！！！！
2.List
List:(元素都带着脚表)
（1）特有方法。凡是可以操作角标的方法都是该体系特有的方法。
1.增
add(index,element);
addAll(index,collection); //从指定的位置开始，将指定 collection 中的所有元素插入到此列表中
2.删
remove(index);
3.改
set(index,element);
4.查
get(index);
subList(from,to);
ListIterator();!!!
（2）代码实例
import java.util.*;
class CollectionDemoText
{
public static void sop(Object obj)
{
System.out.println(obj);
}
public static void main(String[] args)
{
arrayList_method();
}
public static void arrayList_method()
{
ArrayList a11 =new ArrayList();
a11.add("java01");
a11.add("java02");
a11.add("java03");
a11.add("java04");
sop("打印所有元素");
sop(a11);//打印所有元素
//在指定位置添加新元素 add(int index ,E element)
//sop("在指定位置添加了新元素");
//a11.add(2,"java99");
//sop(a11); //打印[java01,java02,java99,java03,java04],集合长度自动增加
//删除指定的元素
//sop("删除指定位置的元素");
//a11.remove(4);
//sop(a11); //打印[java01,java02,java99,java03]
//修改指定位置的元素
//sop("修改指定位置的元素");
//a11.set(2,"java007");
//sop(a11);
//通过角标获取元素
//sop("获取指定位置的元素");
//sop("get(1):"+a11.get(1));
//sop(a11);
//使用子迭代器listIterator
// sop("使用迭代器");
// ListIterator li = a11.listIterator(); //注意写法！！！大小写的区别
// while(li.hasNext())
// {
//****************************************************************************************
// Object obj = li.next();
///-----java01-----java02----java03----java04---
// | | | | |
// |(1) |(2) |(3) |(4) |(5)
// 当程序跑完ListIterator li = a11.listIterator();迭代器的位置在1处！！！
// 当执行it.next(),就跑到（2）处
//Iterator迭代器包含的方法有：
///hasNext()：如果迭代器指向位置后面还有元素，则返回 true，否则返回false
//next()：返回集合中Iterator指向位置后面的元素
//remove()：从迭代器指向的 collection 中移除迭代器返回的最后一个元素（可选操作）。每次调用 next 只能调用一次此方法。
//ListIterator迭代器包含的方法有：
//add(E e): 将指定的元素插入列表，插入位置为迭代器当前位置之前
//hasNext()：以正向遍历列表时，如果列表迭代器后面还有元素，则返回 true，否则返回false
//hasPrevious():如果以逆向遍历列表，列表迭代器前面还有元素，则返回 true，否则返回false
//next()：返回列表中ListIterator指向位置后面的元素
//nextIndex():返回列表中ListIterator所需位置后面元素的索引
//previous():返回列表中ListIterator指向位置前面的元素
//previousIndex()：返回列表中ListIterator所需位置前面元素的索引
//remove():从列表中移除由 next 或 previous 返回的最后一个元素（可选操作）。对于每个 next 或 previous 调用，
//只能执行一次此调用。只有在最后一次调用 next 或 previous 之后，尚未调用 ListIterator.add 时才可以执行该调用。
//set(E e)：从列表中将next()或previous()返回的最后一个元素返回的最后一个元素更改为指定元素e
//************************************************************************
// if(obj.equals("java02"))
/// {
// sop(li);
// //Iterator的子迭代器可以添加元素
// li.add("java88"); //为什么是在java02后面添加元素，而不是在java04?????????上面有讲
/// } //因为迭代器的列表中这时候只有[java01,java02] 还是要看看！！！！
// }
// sop(a11);//[java01,java02,java88,java03,java04]
//使用父类迭代器，注意删除！！！
// sop("使用父类迭代器");
// sop(a11);
// Iterator it = a11.iterator();
// while(it.hasNext())
// {
// Object obj = it.next();
// if(obj.equals("java03"))
// {
// it.remove(); //为什么删的是当前元素！！！？？？？？？上面讲了，看一看
// }
// sop("OBJ--"+obj);//打印 OBJ--java01 OBJ--java02 OBJ--java03 OBJ--java04
// //因为移出只是引用被移除了，但是元素还是在内存中依然被obj使用。所以打印出来了
//局部变量
// }
// sop(a11); //[java01,java02,java04],因为已经被移除了
}
}
(3)List的组成(元素是有序的，元素可以重复。因为该集合体系有索引。) //3
ArrayList:
底层的数据结构使用的是数组结构。特点：查询速度很快，但是增删稍慢（因为要移位，元素多才能体现出来）。线程不同步（可变长度数组，开始默认容量为10，如果超过则增加百分之五十变成15.）
A--->B---->C---D
LinkedList:
底层使用的链表数据结构。特点：增删速度很快（因为只要改动部分,比如BC之间加个E，只要B知道E，E知道C就可以了），查询稍慢（因为一个一个关联，依次往下问）。
Vector:(但是现在不用了)
底层是数组数据结构，线程同步（如果多线程也不用这个）。特点：增删查找都慢。被ArrayList替代了（可变长度数组，开始默认容量为10，如果超过则增加百分之100，变成20，有点浪费.）
淘汰原因
枚举就是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());
}
}
}(4)ArrayList //3
1.ArrayList练习1 //4
需求：取出arrayList集合中的重复元素
arraylist或者linklist中的contain和remove用的都是equals
import java.util.*;
class CollectionDemoText
{
public static void main(String[] args)
{
ArrayList a1 = new ArrayList();
a1.add("java01");
a1.add("java02");
a1.add("java03");
a1.add("java04");
a1.add("java02");
a1.add("java01");
a1.add("java06");
sop("原始集合");
sop(a1);
sop("取出相同的元素");
a1 = removeSameElements(a1);
sop("现在的集合");
sop(a1);
}
public static void sop(Object obj)
{
System.out.println(obj);
}
public static ArrayList removeSameElements(ArrayList a2)
{
ArrayList newa1 = new ArrayList();
Iterator it = a2.iterator();
while(it.hasNext())
{
Object obj = it.next();
if(!newa1.contains(obj))
{
newa1.add(obj);
}
}
//**************************************************************
//开始没有使用临时容器，就靠迭代器迭代然后添加
// ListIterator it = a2.listIterator();
// while(it.hasNext())
// {
// Object obj = it.next();
// sop("1");
// if(!a2.contains(obj)) //如果这么写永远也进不了if内，因为永远包括obj
// {
// sop("2");
// it.add("java22");
// }
// }
// return a2;
//****************************************************************
return newa1;
}
}
2.ArrayList 练习2
需求：将自定义对象作为元素存到ArrayList集合中，并取出重复元素。
比如：存人对象。同姓名同年龄，视为同一个人
//思路：
//1.对人描述，将数据封装进入对象
//2.定义容器，将人存入。
//3.取出
import java.util.*;
class Person
{
private String name;
private int age;
Person(String name,int age)
{
this.name = name;
this.age = age;
}
//弄清一下为什么事在person里面复写？？？因为add里面的元素都是person类的
public boolean equals(Object obj)
{
if(!(obj instanceof Person))
return false;
Person p = (Person)obj ;
System.out.println("p姓名："+p.name+"p年龄 ："+p.age);
System.out.println("姓名："+this.name+"年龄："+this.age);
//String类复写了equals
if((this.name.equals(p.name))&&(this.age == p.age))
{
System.out.println("true");
return true;
}
else
{
System.out.println("false");
return false;
}
}
public String getName()
{
return name;
}
public int getAge()
{
return age;
}
}
class CollectionDemoText
{
public static void sop(Object obj)
{
System.out.println(obj);
}
public static void main(String[] args)
{
ArrayList a1 = new ArrayList();
a1.add(new Person("daxiong",14));
a1.add(new Person("daxiong1",16));
a1.add(new Person("daxiong2",17));
a1.add(new Person("daxiong3",14));
a1.add(new Person("daxiong",16));
a1.add(new Person("daxiong",14));
a1.add(new Person("daxiong2",18));
a1.add(new Person("daxiong3",17));
a1 = removeSameElements(a1);
//打印集合中的元素
Iterator it2 = a1.iterator();
while(it2.hasNext())
{
Person p = (Person)it2.next();
sop(p.getName()+"::"+p.getAge());
}
//打印机集合中的元素
sop("remove daxiong3"+a1.remove(new Person("daxiong3",14)));
}
public static ArrayList removeSameElements(ArrayList a2)
{
ArrayList newa1 = new ArrayList();
Iterator it = a2.iterator();
while(it.hasNext())
{
Object obj = it.next();
if(!newa1.contains(obj))
{
sop("add");
newa1.add(obj);
}
}
return newa1;
}
}
(5)LinkList //3
LinkedList:特有方法： //4
1.老的特有方法 //5
addFirst();
addLast();
getFirst();
getLast();
获取元素，但不删除元素。如果集合中没有元素，会出现NoSuchElementsException
removeFirst();
removeLast();
获取元素，但是元素被删除，如果集合中没有元素，会出现NoSuchElementsException
2.在JDK1.6出现了替代方法
offerFirst();
offerLast();
peekFirst();
peekLast();
获取元素，但不删除元素。如果集合中没有元素，会返回null
pollFirst();
pollLast();
获取元素，但是元素被删除，如果集合中没有元素，会返回null
3.代码实例
import java.util.*;
class CollectionDemoText
{
public static void main(String[] args)
{
methodText();
}
public static void sop(Object obj)
{
System.out.println(obj);
}
public static void methodText()
{
LinkedList a11 = new LinkedList();
//倒序打印
a11.offerFirst("java01");
a11.offerFirst("java02");
a11.offerFirst("java03");
a11.offerFirst("java04");
sop(a11); //打印出[java04,java03,java02,java01]
//正序打印
a11.offerLast("java05");
a11.offerLast("java06");
a11.offerLast("java07");
a11.offerLast("java08");
sop(a11); //打印出[java04,java03,java02,java01,java05,java06,java07,java08]
//获取头尾元素
//sop(a11.peekFirst());
//sop(a11.peekLast());
//删除元素并取出
sop("删除元素并取出");
while(!a11.isEmpty())
{
sop(a11.pollLast());
}
sop("现在集合中的元素");
sop(a11); //因为删光了
}
}
(2)linkedlist小练习 //4
需求：使用LinkedList模拟一个堆栈或者队列数据结构
堆栈：先进后出 如同一个杯子
队列：先进先出 First in First out FIFO 如同一个水管
import java.util.*;
class CollectionDemoText
{
public static void sop(Object obj)
{
System.out.println(obj);
}
public static void main(String[] args)
{
Duilie_Duizhan a1= new Duilie_Duizhan();
a1.myAdd("java01");
a1.myAdd("java02");
a1.myAdd("java03");
a1.myAdd("java04");
while(!a1.nullOrNot())
{
//sop(a1.duiLieGet());
sop(a1.duiZhanGet());
}
}
}
class Duilie_Duizhan
{
private LinkedList lk;
Duilie_Duizhan()
{
lk = new LinkedList();
}
public void myAdd(Object obj)
{
lk.offerFirst(obj);
}
public Object duiZhanGet()
{
return lk.pollFirst();
}
public Object duiLieGet()
{
return lk.pollLast();
}
public boolean nullOrNot()
{
return lk.isEmpty();
}
}
(6)总结
如果增删操作比较多就用linklist
设计增删但不频繁 linklist arraylist
如果还涉及到查找 用arraylist
如果实在不知道用什么就用arraylist
3.Set //2
（1）Set的组成(元素是无序（存入和取出的顺序不一定一致），元素不可以重复) //3
1.HashSet:底层数据结构是哈希表。
HashSet是如何保证元素唯一性的呢？
是通过元素的两个方法，hashcode和equals来完成。
如果元素的HashCode值相同，才会判断equals是否为true.
如果元素的hashcode值不同，不会调用equals.
2.Treeset: //4
底层数据结构是二叉树。
保证元素唯一性的依据。
TreeSet是如何保证元素唯一性的呢？
(1)Treeset排序的第一种方式，让元素自身具备比较性。
元素需要实现compareable接口，覆盖compareTo方法。
这种房也成为元素的自然排序，或者叫做默认顺序。
(2)TreeSet的第二种排序方式。
当元素自身不具备比较性时，或者具备的比较性不是所需要的。
集合需要实现compartor接口 ，然后覆盖compare方法
注意：对于判断元素是否存在，以及删除等操作，依赖的方法是元素的hashcode和equals方法，先判断hascode，再用equals(arraylist lisnklist 都是用equals判断),这是数据结构的问题
(2).HashSet //3
1.代码实现
import java.util.*;
class Demo
{
}
class CollectionDemoText
{
public static void sop(Object obj)
{
System.out.println(obj);
}
public static void main(String[] args)
{
Demo d1 = new Demo();
Demo d2 = new Demo();
//这个地方再看看sop,到底打印什么了？？？？？？<p><span style="white-space:pre"> </span>//两个对象的内存地址，存的顺序不一定是放的顺序，取是按表（按哈希值存）的顺序来存，也可以自定义值</p><p> <span style="white-space:pre"> </span>//Object 类的 toString 方法返回一个字符串，该字符串由类名（对象是该类的一个实例）、at 标记符“@”和此对象哈希码的无符号十六进制表示组成。换句话说，该方法返回一个字符串，它的值等于：
<span style="white-space:pre"> </span>//getClass().getName() + '@' + Integer.toHexString(hashCode())
</p> sop(d1); //会打印出哈希值,其实就是toString,然后toString中的hashcode
sop(d2); //会打印出哈希值//地址
HashSet hs = new HashSet();
sop(hs.add("java01")); //true
sop(hs.add("java01")); //false//地址值一样，内容也一样
hs.add("java02");
hs.add("java03");
hs.add("java04");
hs.add("java05");
Iterator it = hs.iterator();
while(it.hasNext())
{
sop(it.next()); //打印出来是无序的
}
}
}
2.练习 //4
需求：往hashset集合中存入自定义对象姓名和年龄相同为同一个人，重复元素
import java.util.*;
class CollectionDemoText
{
public static void sop(Object obj)
{
System.out.println(obj);
}
public static void main(String[] args)
{
HashSet hs = new HashSet();
hs.add(new Person("java01",13));
hs.add(new Person("java02",14));
hs.add(new Person("java03",15));
hs.add(new Person("java01",13));
hs.add(new Person("java01",14));
hs.add(new Person("java02",17));
Iterator it = hs.iterator();
while(it.hasNext())
{
Person p = (Person)it.next();//迭代器的取出的对象才能强制转换成Person
sop("-名字-"+p.getName()+"-年龄-"+p.getAge());
}
}
}
class Person
{
private String name;
private int age;
Person(String name, int age)
{
this.name = name;
this.age = age;
}
public int hashCode() //自定义哈希值
{
System.out.println(this.name+"....hashCode");
return age*2+this.name.hashCode();//<span style="font-family: 宋体;">随便写的，也可用</span><span style="font-family: 'Times New Roman';">/name.hashcode()*age</span><span style="font-family: 宋体;">但是怕超出范围，这么写的是为了保持哈希值唯一性</span>
}
<span style="white-space:pre"> </span><p><span style="white-space:pre"> </span>//<span style="font-family:宋体;">在哈希表里先看哈希值</span></p> public boolean equals(Object obj)
{
if(!(obj instanceof Person))
return false;
Person p = (Person)obj;
System.out.println(this.name+"..equals.."+p.name);
if((this.name == p.name)&&(this.age == age))
{
return true;
}
else
{
return false;
}
}
public String getName()
{
return name;
}
public int getAge()
{
return age;
}
}
(3)TreeSet //3
1.TreeSet基本特性
底层数据结构是二叉树。
保证元素唯一性的依据。
TreeSet是如何保证元素唯一性的呢？
(1)Treeset排序的第一种方式，让元素自身具备比较性。
(2)TreeSet的第二种排序方式。
元素需要实现compareable接口，覆盖compareTo方法。
这种房也成为元素的自然排序，或者叫做默认顺序。
当元素自身不具备比较性时，或者具备的比较性不是所需要的。
集合需要实现compartor接口 ，然后覆盖compare方法
2.练习1 //4
需求：往Treeset集合中存储自定义对象学生。想按照学生的年龄进行排序。记住排序时，当主要条件相同时，一定判断一下次要条件
第一种 让元素具备可比性
import java.util.*;
//import java.lang.*;
class CollectionDemoText
{
public static void sop(Object obj)
{
System.out.println(obj);
}
public static void main(String[] args)
{
TreeSet a1 = new TreeSet();
a1.add(new Student("java01",13)); //需要具备比较性蓝色字体，
//否则，传两个进来就报错，一个不会（因为不用排序）
a1.add(new Student("java02",14));
a1.add(new Student("java03",13));
a1.add(new Student("java01",13));
a1.add(new Student("java01",17));
Iterator it = a1.iterator();<p><span style="white-space:pre"> </span>/<span style="font-family:宋体;">明明只把</span><span style="font-family:Times New Roman;">age</span><span style="font-family:宋体;">跟</span><span style="font-family:Times New Roman;">name</span><span style="font-family:宋体;">排序，为什么就自动从小到大排序？？？？下面的原理图！！！！！！！！！！</span></p><p>
</p> while(it.hasNext())
{
Student s2 = (Student)it.next();
sop("-名字-"+s2.getName()+"年龄"+s2.getAge());
//-名字-java01年龄13
//-名字-java03年龄13
//-名字-java02年龄14
//-名字-java01年龄17
}
}
}
class Student implements Comparable
{
private String name;
private int age;
Student(String name , int age)
{
this.name = name;
this.age = age;
}
public String getName()
{
return name;
}
public int getAge()
{
return age;
}
public int compareTo(Object obj)
{</pre><pre name="code" class="java"><p><span style="white-space:pre"> </span>//return 1; //<span style="font-family:宋体;">也就是说下一个元素比上一个大</span></p><p><span style="white-space:pre"> </span>//return -1;//<span style="font-family:宋体;">也就是说下一个元素比上一个小</span></p><p>//return 0;//<span style="font-family:宋体;">也就是说下一个元素等于上一个元素</span></p>
if(!(obj instanceof Student))
{
throw new RuntimeException("不是学生对象");
}
Student s1 = (Student)obj;
if(this.age > s1.age)
{
return 1;
}
else if(this.age <s1.age)
{
return -1;
}
else
{
//String 方法有compareTo这个方法
//ask码值大的就返回1，排后面面
//-1排前面面
//-名字-java01年龄13
//-名字-java03年龄13
//-名字-java02年龄14
//-名字-java01年龄17
return this.name.compareTo(s1.name);
}
}
}/明明只把age跟name排序，为什么就自动从小到大排序？？？？下面的原理图
treeset底层结构是二叉树，之前回说为什么只是做了比较，但是却没排序却自动排序了，试音，return 1 return 0 return -1的原因，自动把小的那边放到左边（例如 20放到22的左下角），还有下面（例如，左下角有两个19，但是08小于09，所以就放他的左下角）
第二种让集合具备可比性.
当元素自身不具备比较性，或者具备的比较性不是所需要的。
这时需要让容器自身具备比较性。
定义了比较器，将比较器对象作为参数传递给TreeSet集合的构造函数
当两种排序都存在时，以比较器为主。
定义了一个类，实现conparator接口，覆盖compare方法（接口在treeset构造函数中）
import java.util.*;
//import java.lang.*;
class CollectionDemoText
{
public static void sop(Object obj)
{
System.out.println(obj);
}
public static void main(String[] args)
{
TreeSet a1 = new TreeSet(new MyCompare());
a1.add(new Student("java01",13)); //需要具备比较性蓝色字体，
//否则，传两个进来就报错，一个不会（因为不用排序）
a1.add(new Student("java02",14));
a1.add(new Student("java03",13));
a1.add(new Student("java01",13));
a1.add(new Student("java01",17));
Iterator it = a1.iterator();
while(it.hasNext())
{
Student s2 = (Student)it.next();
sop("-名字-"+s2.getName()+"年龄"+s2.getAge());
//-名字-java01年龄13
//-名字-java03年龄13
//-名字-java02年龄14
//-名字-java01年龄17
}
}
}
class Student
{
private String name;
private int age;
Student(String name , int age)
{
this.name = name;
this.age = age;
}
public String getName()
{
return name;
}
public int getAge()
{
return age;
}
}
class MyCompare implements Comparator
{
public int compare(Object obj1, Object obj2)
{
Student s1 = (Student)obj1;
Student s2 = (Student)obj2;
int num = s1.getName().compareTo(s2.getName());
if(num == 0)
{
<span style="white-space:pre"> </span><p></p><p><span style="white-space:pre"> </span>//<span style="font-family:宋体;">为什么要用</span><span style="font-family:Times New Roman;">integer</span><span style="font-family:宋体;">，让他变成对象是为什么？？？是不是</span><span style="font-family:Times New Roman;">compareTo</span><span style="font-family:宋体;">的参数就是需要对象？？？？对的 ！！！！！</span></p><p><span style="white-space:pre"> </span>//<span style="font-family:宋体;">因为</span><span style="font-family:Times New Roman;">name </span><span style="font-family:宋体;">是</span><span style="font-family:Times New Roman;">String</span><span style="font-family:宋体;">类对象</span></p> return new Integer(s1.getAge()).compareTo(new Integer(s2.getAge()));
}
return num;
}
}
3.练习2 //4
需求：按照字符串长度排序。字符串本身具备比较性。但是他的比较方式不是所需要的。这时就只能使用比较器。
import java.util.*;
class CollectionDemoText
{
public static void main(String[] args)
{
TreeSet ts = new TreeSet(new StrLenComparator());
ts.add("abcd");
ts.add("cc");
ts.add("cba");
ts.add("hahaha");
ts.add("abc");
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;
int num = new Integer(s1.length()).compareTo(new Integer(s2.length()));
if(num == 0)
{
return s1.compareTo(s2); //长度相同，判断内容是否相同
//String 其实继承了compareable这个接口，然后写了compareTo这个方法
//，例如 ac ab,字符少的放前面顺序就是 ab ac就是Ask码值相减
}
return num;
}
}
泛型 //2
1.泛型：JDK1.5版本以后出现新特性，用于解决安全问题，是一个类型安全机制。
2.使用泛型的好处
1.将运行时期出现问题classcastException，转移到了编译时期，
方便于程序员解决问题，让运行事情问题减少，安全。
2.避免强制转换麻烦。
3.泛型格式：通过<>来定义遥操作的引用数据类型。
4.什么时候使用泛型？
通常在集合框架中很常见。
只要见到<>就要定义泛型（在API中可以看到例如arraylist<E>）
其实<>就是用来接收类型的。
当使用集合时，将集合中要存储的数据类型作为参数传递到<>中即可
5.老版
class GenericDemo
{
public static void main(String[] args)
{
ArrayList al = new ArrayList(); //没有明确数据类型，所以引起安全隐患
//ArrayList<String> a1 = new ArrayList<String>();//2这种是安全的
al.add(“abc01”);
al.add(“abc0991”);
al.add(“abc014”);
al.add(4);//al.add(new Interger(4));//在这里会引起运行报错，因为不能把 Interger(4)转换为string
//把数据取到迭代器中2
Iterator<String> it = al.interator();//明确了迭代器中的数据类型
while(it.hasNext())
{
//String s = （string）it.next();//length是String特有的方法，所以强转
String s = it.next();//写了代码2 就不用强转
System.out.println(s+”:”+s.length());
}
}
}
6.新版
class GenericDemo
{
public static void main(String[] args)
{
ArrayList<String> al = new ArrayList<String>();//定义一个arraylist容器，里面的元素是string型，指定类型为String
al.add(“abc01”);
al.add(“abc0991”);
al.add(“abc014”);
//al.add(4);//al.add(new Interger(4));
Iterator<String> it = al.interator();//将数据取到迭代器，所以也必须说明迭代器也是string型的？？？？？？？ 知道了，如果不这么做下面就要写成String s = （string）it.next();
while(it.hasNext())
{
String s = it.next();
System.out.println(s+”:”+s.length());
}
}
}
7.泛型的使用
import java.util.*;
class GenericDemo2
{
public static void main(String[] args)
{
<span style="white-space:pre"> </span>TreeSet<String> ts = new TreeSet<String>(new LenComparator());
<span style="white-space:pre"> </span>ts.add(“abcd”);
<span style="white-space:pre"> </span>ts.add(“cc”);
<span style="white-space:pre"> </span>ts.add(“cba”);
<span style="white-space:pre"> </span>ts.add(“aaa”);
<span style="white-space:pre"> </span>ts.add(“z”);
<span style="white-space:pre"> </span>ts.add(“hahaha”);
<span style="white-space:pre"> </span>Iterator<String> it = ts.iterator();
<span style="white-space:pre"> </span>while(it.hasNext())
<span style="white-space:pre"> </span>{
<span style="white-space:pre"> </span>String s = it.next();
<span style="white-space:pre"> </span>System.out.println(s); <span style="white-space:pre"> </span> //打印aaa
<span style="white-space:pre"> </span>abcd
<span style="white-space:pre"> </span>cba
<span style="white-space:pre"> </span> cc
<span style="white-space:pre"> </span> hahaha
<span style="white-space:pre"> </span> z
<span style="white-space:pre"> </span>为了能够按字符长度打印，所以下面写了个比较的函数
}
}
}
class LenComparator Implements Comparator<String>//有的没有参数（只有<>），不能写<>!!!一定要使用强转（代码3），有参数的叫泛型类
//没看懂？？？？？？？？？？？看懂了，compartor写了<String>,后面就不需要写代码3
{
<span style="white-space:pre"> </span> public int compare（String o1,String o2）
<span style="white-space:pre"> </span>{
<span style="white-space:pre"> </span>//String s1 = (String)o1; // 代码3
<span style="white-space:pre"> </span>//String s2 = (String)o2;
<span style="white-space:pre"> </span>int num = new Interger(o2.length()).compareTo(new Interger(o1.length()));
<span style="white-space:pre"> </span>if(num == 0)
<span style="white-space:pre"> </span>return o2.compareTo(o1);
<span style="white-space:pre"> </span>return num;
<span style="white-space:pre"> </span>}
}
8.泛型类
class Worker
{
}
class student
{
}
class Tool //通用性不好，每创建一个类都得重写一个
{
private Worker w;
public void setWorker(Worker w)
{
this.w = w;
}
public Worker getWorker()
{
return w;
}
}
1泛型前做法
class Tool //通用性很好
{
private Object obj;
public void setObject (Object obj)
{
this.obj= obj;
}
public Object setObject ()
{
return obj;
}
}
2.泛型后做法
什么时候定义泛型类？
当类中要操作的引用数据类型不确定的时候
早期定义object来完成扩展。
现在定义泛型来完成扩展
class Utils<QQ>
{
private QQ q;
public void setObject(QQ q)
{
this.q = q;
}
public QQ getobject()
{
return q;
}
}
class GenericDemo3
{
public static void main(String[] args)
{
//泛型前 //看的不是很明白？？？？？看明白了
//Tool t = new Tool();
//t.setObject (new Worker()); //这里如果new student()编译不会报错，因为是用objext来接收的
//Worker w = (Worker)t.getObject();
//泛型后
Utils<Worker> u = new Utils<Worker>();
U.setObject(new Worker()); //如果改成 new student();会在编译过程中报错，这就是使用泛型的好处，如果没用可能会在执行过程中报错
Worker w = u.getObject();
}
}
三.Map
1.共性方法 //2
Map<K,V>
K-此映射所维护的键的类型
V-映射值的类型
map集合：该集合存储键值对，一堆一堆往里存。而且要保证键的唯一性。
1.添加
put(K key , V value)
putAll(Map<? extends K , ? extends V>m)
2.删除
clear()
remove(object key)
3.判断
containsValue(Object value)
containskey(Object key)
isEmpty()
4.获取
get(Object key)
size()
value()
entrySet()
keySet()
5.代码实现 //3
1.
import java.util.*;
class CollectionDemoText
{
public static void sop(Object obj)
{
System.out.println(obj);
}
public static void main(String[] args)
{
Map<String,String> ha = new HashMap<String , String>();
sop("put1-"+ha.put("01","dx1"));//打印null,因为会返回与key关联的旧值，如果key没有任何映射关系，则返回Null
sop("put1-"+ha.put("01","dx2"));//打印dx1
ha.put("03","dx1");
ha.put("04","dx1");
ha.put("05","dx7");
sop(ha);
sop("是否包含023这个键-"+ha.containsKey("023"));//打印false
sop("是否包含dx4这个值-"+ha.containsValue("dx4"));//打印false
sop("是否包含01这个键-"+ha.containsKey("01"));//打印false
sop("是否包含dx2这个值-"+ha.containsValue("dx2"));//打印false
sop("移出键07-"+ha.remove("07"));//返回与key关联的旧值，不存在就返回null
sop("移出键05-"+ha.remove("05"));//dx7
ha.put("06",null);//这么写但是多大没意义
sop("获取键06的值"+ha.get("o6"));//指定键所映射的值；如果此映射不包含该键的映射关系，则返回 null
sop("获取键04的值"+ha.get("04"));
//获取map集合中所有的值
Collection<String> coll = ha.values();//values返回此映射中包含的值的 collection 视图
sop(coll); //[dx2,dx1,dx1,null]
sop(ha); //{01 = dx2,03 = dx1, 04 = dx1 , 06 = null}
}
}
2.keySet(),entrySet() //4
get只能获取对应的一个键值，能不能获取很多键值，这就是写这个的原因
1.Set <k>keyset：将map中所有的键存入到set集合。因为set具备迭代器。
所有可以迭代方式取出所有的键，在根据get方法。获取每个键对应的值。
原理：map集合的取出原理：将map集合转成set集合。在通过迭代器取出。
2.Set<Map.entry<k,v>> entrySet: 将map集合中的映射关系存入到了set1集合中，而这个关系的数据类型就是: Map.Entry
1.key取值方式
2.mapentry获取键值原理
import java.util.*;
class CollectionDemoText
{
public static void sop(Object obj)
{
System.out.println(obj);
}
public static void main(String[] args)
{
Map<String,String> ma = new HashMap<String,String>();
ma.put("02","dx1");
ma.put("02","dx2");
ma.put("03","dx3");
ma.put("04","dx4");
ma.put("05","dx5");
ma.put("06","dx1");
//使用keySet迭代取值
// Set<String> s1 = ma.keySet();//返回此映射中所包含的键(!!!!!)的 Set 视图
// Iterator<String> it = s1.iterator();
// while(it.hasNext())
// {
// String key = it.next();
// String value = ma.get(key);
// sop("key"+key+"-value-"+value);
// //sop(it.next()+"对应的值"+ma.get(it.next()));//这样调用会出现noSuchElements
<span style="white-space:pre"> </span>//因为会调用到06的时候已经是最后一个值了，再来个it.next(),就没值了，
//就会抛出noSuchElements（没有元素可以迭代）
// }
//使用entrySet迭代取值
Set<Map.Entry<String,String>> e1 = ma.entrySet();//返回此映射所包含的映射关系(也就是<Map.entry<String,String>!!!!)的 Set 视图
Iterator<Map.Entry<String,String>> it2 = e1.iterator();
while(it2.hasNext())
{
Map.Entry<String,String> ma1 = it2.next();
String key = ma1.getKey();
String value = ma1.getValue();
sop("key"+key+"-value-"+value);
}
}
}
//map.entry 其实entry也是一个借口，他是map借口中的一个内部接口
interface Map //有map集合才能有entry(代表映射关系)关系，可以说是map集合的内部事物，可以直接访问map集合的内部元素，所以才定义在内部，能加<span style="white-space:pre"> </span>//static的接口<span style="white-space:pre"> </span>一般都是内部接口！！！！！！！，因为只有接口在成员位置上才能加静态修饰符？？？（这个不太明白）
{
public static interface entry
{
public abstract Object getkey();
public abstract Object getvalue();
}
}
class HashMap implements map.Entry //内部类来实现entry,外部类实现map
{
class haha implements Map.entry
{
public Object getkey(){}
public Object getvalue(){}
}
}
2.Map的组成 //2
Hashtable:底层是哈希表数据结构，不可以存入null键null值。该集合是线程同步的。jdk1.0
HashMap:底层是哈希表数据结构，允许存入null键null值。该集合是线程不同步的。jdk1.2
Treemap底层是二叉树数据结构。线程不同步。可以用于给map集合中的键进行排序。
注意：和set很像，其实大家。set底层就是使用了map集合！！！！！！！
(1)TreeMap练习1 //3
需求：对学生对象的年龄进行升序排序。
因为数据是以键值对形式存在的。
所以要使用可以排序的map集合。treemap.
//让元素具有比较性，还有如果按名字来排序应该怎么搞（试一试这个！！！！）搞定
方法一让元素具有可比性排序
import java.util.*;
class Student implements Comparable<Student>
{
private String name;
private int age;
Student(String name , int age)
{
this.name = name;
this.age = age;
}
public String getName()
{
return name;
}
public int getAge()
{
return age;
}
public int hashCode()
{
return age*2+name.hashCode(); //String类型有hashcode
}
public boolean equals(Object obj)
{
if(!(obj instanceof Student))
{
throw new ClassCastException("类型不匹配");
}
Student p = (Student)obj;
return ((this.name.equals(p.name)) && ((this.age == p.age)));//可不可以采用this.name.compareTo(p.name)
//equals返回的是正负
}
public int compareTo(Student s1) //注意复写，要把参数类型也要复写，如果写Student s1会报错
//因为没写Comparable<Student>，所以只能写conpareTO(Object obj)
{
//if(!(obj instanceof Student))
// {
// throw new ClassCastException("比对类型不匹配")
// }
//按照年龄排序******************************************************************************
int num = (new Integer(s1.age)).compareTo(new Integer(this.age));
if(num == 0)
{
return this.name.compareTo(s1.name); //返回的是1 ， 0 ， -1
}
else
{
return num;
}
//*******************************************************************************************
//按照名字排序**************************************
int num = s1.name.compareTo(this.name);
if(num == 0)
{
return (new Integer(s1.age)).compareTo(new Integer(this.age));
}
else
{
return num;
}
//*****************************************************
}
}
class CollectionDemoText
{
public static void sop(Object obj)
{
System.out.println(obj);
}
public static void main(String[] args)
{
//记住只有TreeMap才能排序！！！！！！！
TreeMap<Student , String> ma = new TreeMap<Student , String>();
ma.put(new Student("dx1",111),"beijing");
ma.put(new Student("dx1",111),"tianjing");
ma.put(new Student("dx2",13),"beijing");
ma.put(new Student("dx3",45),"jiangxi");
ma.put(new Student("dx5",52),"guangdong");
ma.put(new Student("dx6",11),"fujian");
sop(ma);
//用keySet取值
sop("keySet.set取值排列入下");
Set<Student> keyset = ma.keySet();
Iterator<Student> it = keyset.iterator();//Iterator <Student> it =keySet.iterator()；
while(it.hasNext())
{
Student key = it.next();
String value = ma.get(key);
sop("学生："+key.getName()+"年龄："+key.getAge()+"地址:"+value);
}
//用entry.Set取值
sop("ENtry.set取值排列入下");
Set<Map.Entry<Student , String >> entryset = ma.entrySet();
Iterator<Map.Entry<Student , String >> it1 = entryset.iterator();//Iterator<Map.Entry<Student , String >> it = entrySet.iterator();
while(it1.hasNext())
{
Map.Entry<Student , String > ma1 = it1.next();
Student key = ma1.getKey();
String value = ma1.getValue();
sop("学生："+key.getName()+"年龄："+key.getAge()+"地址:"+value);
}
}
}
方法二 让集合具有比较性，用比较器比较
import java.util.*;
class Student
{
private String name;
private int age;
Student(String name , int age)
{
this.name = name;
this.age = age;
}
public String getName()
{
return name;
}
public int getAge()
{
return age;
}
public int hashCode()
{
return age*2+name.hashCode(); //String类型有hashcode
}
public boolean equals(Object obj)
{
if(!(obj instanceof Student))
{
throw new ClassCastException("类型不匹配");
}
Student p = (Student)obj;
return ((this.name.equals(p.name)) && ((this.age == p.age)));//可不可以采用this.name.compareTo(p.name)
//equals返回的是正负
}
}
class MyCompare implements Comparator<Student>
{
public int compare(Student s1 ,Student s2)
{
//按照年龄排序**********************************
if(s1.getAge()>s2.getAge())
{
return -1;
}
else
if(s1.getAge()<s2.getAge())
{
return 1;
}
else
{
return s1.getName().compareTo(s2.getName());
}
//************************************************
//按照名字排序*********************************
int num = s1.getName().compareTo(s2.getName());
if(num == 0)
{
return new Integer(s1.getAge()).compareTo(new Integer(s2.getAge()));
}
else
{
return num;
}
//按照名字排序*********************************
}
}
class CollectionDemoText
{
public static void sop(Object obj)
{
System.out.println(obj);
}
public static void main(String[] args)
{
TreeMap<Student , String> ma = new TreeMap<Student , String>(new MyCompare());
ma.put(new Student("dx1",111),"beijing");
ma.put(new Student("dx1",111),"tianjing");
ma.put(new Student("dx2",13),"beijing");
ma.put(new Student("dx3",45),"jiangxi");
ma.put(new Student("dx5",52),"guangdong");
ma.put(new Student("dx6",11),"fujian");
sop(ma);
//用keySet取值
sop("keySet.set取值排列入下");
Set<Student> keyset = ma.keySet();
Iterator<Student> it = keyset.iterator();//Iterator <Student> it =keySet.iterator()；
while(it.hasNext())
{
Student key = it.next();
String value = ma.get(key);
sop("学生："+key.getName()+"年龄："+key.getAge()+"地址:"+value);
}
//用entry.Set取值
sop("ENtry.set取值排列入下");
Set<Map.Entry<Student , String >> entryset = ma.entrySet();
Iterator<Map.Entry<Student , String >> it1 = entryset.iterator();//Iterator<Map.Entry<Student , String >> it = entrySet.iterator();
while(it1.hasNext())
{
Map.Entry<Student , String > ma1 = it1.next();
Student key = ma1.getKey();
String value = ma1.getValue();
sop("学生："+key.getName()+"年龄："+key.getAge()+"地址:"+value);
}
}
}
(2)TreeMap练习2 //3
需求：asdasfsdasdasgdfhert”获取该字符串中的字母出现的次数,希望打印结果：a(1)c(2)
通过结果发现，每一个字母都有对应的次数。
说明字母和次数之间都有映射关系。
注意了，当发现有映射关系时，可以选择map集合。
因为map集合中存放就是映射关系。
为什么使用map集合呢？
当数据之间存在着映射关系时，就要先想map集合。
思路：
1.将字符串转换成字符数组。因为要对每一个字母进行操作
2.定义一个map集合，因为打印结果的字母有顺序，所以使用treemap集合。
3.遍历字符数组。
将每一个字母作为键去查map集合。
如果返回null,将该字母和1存入到map集合中。
如果返回不是null,说明该字母在map集合已经存在并有对应次数。
那么就获取该次数并进行自增，然后将该字母和自增后的次数存入到map集合，覆盖调用原来键所对应的值。
4.将map集合中的数据变成指定的字符串形式返回。
import java.util.*;
class CollectionDemoText
{
public static void sop(Object obj)
{
System.out.println(obj);
}
public static void main(String[] args)
{
String s1 = charCount("asdasfsdasdasgdfhert");
sop(s1);
}
public static String charCount(String str)
{
char [] chs = str.toCharArray();//变成数组<p><span style="white-space:pre"> </span>//<span style="font-family:宋体;">泛型类接受的都是引用数据类型，所以要写基本的数据包装类</span><span style="font-family:Times New Roman;">(character,Interger),</span><span style="font-family:宋体;">而不是，</span><span style="font-family:Times New Roman;">char,int.</span></p> TreeMap<Character , Integer> trma =new TreeMap<Character , Integer>();
int count = 0;
for(int i = 0 ;i<chs.length;i++) //length , length(),size
{
if(!((chs[i]>= 'a' && chs[i] <='z')||(chs[i]>='A' && chs[i] <='Z')))//避免算其他字符被拿进来
continue;
Integer value = trma.get(chs[i]);
sop("第i个-"+i+"--是--"+chs[i]+"--值--"+value);
//这样也可以**************************************
// if(value == null)
// {
// trma.put(chs[i],1);
// }
// else
// {
// value = value+1;
// //value++;
// trma.put(chs[i],value);
// }
//这样也可以***************************************
if(value != null)
{
count = value;
}
else
{
count = 0; //这个地方换了一个字符就一定要清零，否则结果不对
}
count++;
sop("第i个-"+i+"--是--"+chs[i]+"出现次数"+count);
trma.put(chs[i],count);
}
//!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
StringBuilder sb = new StringBuilder(); //这个地方要好好看下，可以自定义打印的形式a(2)b(3)..
Set<Map.Entry<Character , Integer>> enset = trma.entrySet();
Iterator<Map.Entry<Character , Integer>> it = enset.iterator();
while(it.hasNext())
{
Map.Entry<Character , Integer> mapen = it.next();
Character chs1 = mapen.getKey();
Integer in1 = mapen.getValue();
sb.append(chs1+"("+in1+")");
}
return sb.toString();
}
}3.Map扩展知识 //2
有两种方法，没看出来有很大差别？？？？？？？？
一对多，一般都是把学生封装成对象，用后者方法
map集合被使用是因为具备映射关系。
winsun 下属业务部，工程部
业务部 下属 dx1 01
dx2 02
dx3 03
都按照年龄排序
工程部 下属 dx4 22
dx5 23
dx6 24
方法1，用map嵌套
import java.util.*;
class CollectionDemoText
{
public static void sop(Object obj)
{
System.out.println(obj);
}
public static void main(String[] args)
{
//这里可以写map.但是后面就不能写了，因为是接口，抽象的，不能实例化
HashMap<String ,HashMap<String ,String > > winsun = new HashMap<String ,HashMap<String ,String > >();
HashMap<String ,String > yewu = new HashMap<String ,String >(); //要放在前面，要不然后面无法添加
HashMap<String ,String > gongcheng = new HashMap<String ,String >();
winsun.put("yewubu",yewu);//这么写规不规范
winsun.put("gongchengbu",gongcheng);
yewu.put("dx1","22");
yewu.put("dx2","25");
yewu.put("dx3","26");
gongcheng.put("dx4","27");
gongcheng.put("dx5","25");
gongcheng.put("dx6","24");
sop("业务部人员信息");
getPersonInfo(yewu);//获取业务部的人员信息 //如果想用toString怎么弄
sop("工程部人员信息");
getPersonInfo(gongcheng);//获取业务部的人员信息
sop("获取部门信息");
getDepartmentInfo(winsun);
}
public static void getDepartmentInfo(HashMap<String ,HashMap<String ,String > > tm)
{
//用keySet取值
sop("用的是keyset");
Set<String> keyset = tm.keySet();
Iterator<String> it = keyset.iterator();
while(it.hasNext())
{
String key = it.next();
HashMap<String ,String > value =tm.get(key);
sop("key-"+key+"-value-"+value);
}
sop("用的是entryset");
//用entrySetq取值
Set<Map.Entry<String ,HashMap<String ,String >>> enset = tm.entrySet();//传的是TreeMap，这里用用Map.entry();
Iterator<Map.Entry<String ,HashMap<String ,String >>> it1 = enset.iterator();
while(it1.hasNext())
{
Map.Entry<String ,HashMap<String ,String >> map = it1.next();
String key = map.getKey();
HashMap<String ,String > value = map.getValue();
sop("key-"+key+"-value-"+value);
}
}
//public static void getPersonInfo(Map tm)//会报错，不兼容性的类型，object无法转换成String
public static void getPersonInfo(HashMap<String , String> tm)
{
//用keySet取值
Set<String> keyset = tm.keySet();
Iterator<String> it = keyset.iterator();
while(it.hasNext())
{
String key = it.next();
String value =tm.get(key);
sop("key-"+key+"-value-"+value);
}
//用entrySetq取值
Set<Map.Entry<String,String>> enset = tm.entrySet();//传的是TreeMap，这里用用Map.entry();
Iterator<Map.Entry<String,String>> it1 = enset.iterator();
while(it1.hasNext())
{
Map.Entry<String,String> map = it1.next()
String key = map.getKey();
String value = map.getValue();
sop("key-"+key+"-value-"+value);
}
}
}
方法2，把学生做成一个集合
import java.util.*;
class Person
{
private String name ;
private int age;
Person(String name,int age)
{
this.name = name;
this.age = age;
}
public String getName()
{
return name;
}
public int getAge()
{
return age;
}
public String toString()
{
return age+":::"+name;
}
}
class CollectionDemoText
{
public static void sop(Object obj)
{
System.out.println(obj);
}
public static void main(String[] args)
{
HashMap<String ,List<Person>> czbk = new HashMap<String ,List<Person>>();
List<Person> yure = new ArrayList<Person>();
List<Person> jiuye = new ArrayList<Person>();
czbk.put("yureban",yure);
czbk.put("jiuyeban",jiuye);
yure.add(new Person("dx1",11));
yure.add(new Person("dx2",13));
jiuye.add(new Person("dx2",11));
jiuye.add(new Person("dx11",11));
Iterator<String> it = czbk.keySet().iterator();
while(it.hasNext())
{
String roomName = it.next();
List<Person> room =czbk.get(roomName);
System.out.println(roomName);
getInfos(room);
}
}
public static void getInfos(List<Person> List)
{
Iterator <Person> it = List.iterator();
while(it.hasNext())
{
Person s = it.next();
System.out.println(s); //打印的其实就是toString
}
}
}
四.集合框架的工具类
1.作为工具类，它里面的方法全是静态的不需要对象
2.不需要保证唯一，用list，但是要排序，又只能用tree
所以这里就是collections
注意：
public static <T extends Compareable <? super T>>void sort(List<T> list)
这句话的意思是T 必须是Compareable 的子类，<? super T>这个代表T的父类，可以传person
list集合中的元素想要排序都要进行比较，如果不写extend Comparable限定T，传过来如果是没有比较性，如果运行就会出错，然后comparable也要写泛型一般写Comparable<T>现在Comparable<? super T>（? super T 表示用T或者用T的父类来比）
public static <T extend Comparable<? super T>> void sort(List<T> list)
1.sort
import java.util.*;
class CollectionDemoText
{
public static void sop(Object obj)
{
System.out.println(obj);
}
public static void main(String[] args)
{
List<String> list = new ArrayList<String>();
list.add("asdasd");
list.add("qwe");
list.add("sf");
list.add("dfgdf");
list.add("vsf");
list.add("sdfr");
list.add("yujghy");
sop(list);//按存入的顺序打印
sop("按自然顺序排序");
Collections.sort(list); //collections不能给set用,因为他自己有treeset
sop(list);
//用二分法查找 //这里传入的元素是具有比较性的
int index = Collections.binarySearch(list , "sdfr");//系统的//如果找不到就返回插入点
sop("index--"+index);
//用二分法查找 //传入不具备比较性的元素，用比较器
自己写一下二分法查找！！！！
自己写一下二分法查找！！！！
sop("按自己写的自然顺序排序");
Collections.sort(list, new NormalCompartor()); //注意这里的写法！！
sop(list);
sop("按字符长度排序");
Collections.sort(list, new StrLengthCompartor());
sop(list);
//获取长度最长的
String max = Collections.max(list);
sop("max--"+max);
}
}
class StrLengthCompartor implements Comparator<String>
{
public int compare(String s1 ,String s2)
{
if(s1.length()>s2.length())
{
return -1;
}
else
if(s1.length()<s2.length())
{
return 1;
}
else
{
return s1.compareTo(s2);
}
}
}
class NormalCompartor implements Comparator<String>
{
public int compare(String s1 ,String s2)
{
return s1.compareTo(s2);
}
}2.替换部分元素
import java.util.*;
class CollectionDemoText
{
public static void sop(Object obj)
{
System.out.println(obj);
}
public static void main(String[] args)
{
//replacePartDemo();
replaceAllDemo();
}
public static void replacePartDemo()
{
List<String> list = new ArrayList<String>();
list.add("abcd");
list.add("aaa");
list.add("qwe");
list.add("z");
list.add("qweqwe");
list.add("sd");
sop(list);(1)使用替换函数replaceAll
sop("使用替换函数");
//static <T> boolean replaceAll(List<T>,T oldVal , T newVal)
boolean flag = Collections.replaceAll(list,"z","ww");
sop(flag);
sop(list);
}(2)替换所有元素
public static void replaceAllDemo()
{
List<String> list = new ArrayList<String>();
list.add("fgj");
list.add("fghr");
list.add("se");
list.add("z");
list.add("czxc");
list.add("bcv");
sop(list);
(3)使用替换函数fill
sop("使用替换函数fill");
//static <T> boolean replaceAll(List<T>,T oldVal , T newVal)
Collections.fill(list,"ww");
sop(list);
}
}
3.实现反转
import java.util.*;
class CollectionDemoText
{
public static void sop(Object obj)
{
System.out.println(obj);
}
public static void main(String[] args)
{
orderDemo();
}
public static void orderDemo()
{
// TreeSet<String> ts = new TreeSet<String>(new StrComparator());//使用自定义比较器
// reverseOrder()返回一个比较器，它强行逆转实现了Comparable接口的对象Collection的自然顺序
// TreeSet<String> ts = new TreeSet<String>(Collections.reverseOrder());//最简单的方法//系统自带，collections.reverseorder()返回的是一个比较器
// reverseOrder()返回一个比较器，它强行逆转指定比较器的顺序
// TreeSet<String> ts = new TreeSet<String>(Collections.reverseOrder(new StrComparator())); //强制反转已有的比较器，这个方法更牛
// TreeSet<String> ts = new TreeSet<String>();//使用默认的比较方式
ts.add("abcde");
ts.add("aaa");
ts.add("kkk");
ts.add("ccc");
Iterator it = ts.iterator();
while(it.hasNext())
{
sop(it.next());
}
}
}
class StrComparator implements Comparator<String> //自定义的比较器
{
public int compare(String s1, String s2) //在这里加了个分号，报错误，缺少方法主体，或声明抽象
{
return s2.compareTo(s1);//正常的情况是s1.compareTo(s2)，但是这里我们需要倒序
}
}
五..Arrays:用于操作数组的工具类。
1.asList:将数组变成list集合
还有String变成char???????????
import java.util.*;
class CollectionDemoText
{
public static void sop(Object obj)
{
System.out.println(obj);
}
public static void main(String[] args)
{
int[] arr = {2,4,5};
sop(arr);//只会打印哈希值
sop(Arrays.toString(arr)); //返回字符串形式[2,4,5]
//把数组变成list集合有什么好处？
// 可以使用集合的思想和方法来操作数组中的元素。
// 注意：将数组变成集合，不可以使用集合的增删方法。
// 因为数组的长度是固定。
// contains
// get
// indexof()
// subList();
// 如果你增删。那么回反生unsupportedOperationException,
// sop(list);
String[] arr = {"asd","qwe","sdf"} ;
List<String> list = Arrays.asList(arr)
}
}
六.一些扩展
1.集合变数组
Collection接口中的toArray方法。。传什么类型，返回就什么类型
import java.util.*;
class collectionToArray
{
public static void main(String[] args)
{
ArrayList<String> a1 = new ArrayList<String>();
a1.add(“abc1”);
a1.add(“abc2”);
a1.add(“abc3”);
1.指定类型的数组到底要定义多长呢？
当指定类型的数组长度小于集合的size,那么该方法内部会创建一个新的数组，长度为集合的size.
当指定类型的数组长度大于了集合的size，就不会新创建了数组，而是使用传递进来的数组。所以创建一个刚刚好的数组最优。（把 new String[0]改为new String[a1.size()]）
2，为什么要将集合变数组？
为了限定对元素的操作，不需要进行增删了（集合长度可变，数组长度固定）
String[] arr = a1.toArray(new String[0](改成String[a1.size()]))//如果Sting[5](超过数组长度)，会打印出[abc1,abc2,abc3,null,null]
System.out.println(Arrays.toString(arr)); //[abc1,abc2,abc3]
}
}
2.高级for循环
格式：
for(数据类型 变量名 ： 被遍历的集合（Collection）或者数组)
{
}
注意：
对集合进行遍历。
只能获取集合元素。但是不能对集合进行操作。
迭代器除了遍历，还可以进行remove集合中元素的动作。
如果是用ListIterator,还可以在遍历过程中对集合进行增删改查的动作。
传统for和高级for有什么区别呢？
高级for有一个局限性。必须有被遍历的目标。
建议在遍历数组的时候，还是希望用传统的for.因为传统for可以定义脚标
import java.util.*;
class ForEachDemo
{
public static void main(String[] args)
{
ArrayList<String> a1 =new ArrayList<String>();
a1.add(“abc1”);
a1.add(“abc2”);
a1.add(“abc3”);
for(String s : a1) //只能取出，不能改变连remove都不行（iterator可以）
{
//s= “KK”;//不会影响打印的结果
System.out.println(s);
}
System.out.println(a1);
/*
Iterator <String> it = a1.iterator();
while(it.hasNext())
{
System.out.println(it.next());
}
*/复杂了
*/
int [] arr = {3,5,1};
for(int i:arr)
{
System.out.println(“i:”+i);
}
HashMap<Integer,String> hm =new HashMap<Integer , String>();
hm.put(1,”a”);
hm.put(2,”b”);
hm.put(3,”c”);
Set<Integer> keySet = hm.keySet();
for(Integer i : keySet)
{
System.out.println(i+”::”+hm.get(i));// 打印 1：：a 2::b 3::c
}
/*
Set<Map.Entry<Interger , String>> entrySet = hm.entrySet();
for(Map.Entry<Integer, String > me : entrySet)
*///复杂了可以简写成下面的
for(Map.Entry<Integer , String > me : hm.entrySet())
{
System.out.println(me.getKey()+”------”+me.getValue());
}
3.方法的可变参数
在使用时注意：可变参数一定要定义在参数列表最后面。
例如
如果
show (“haha”,2,3,4,5,6);
则需要show函数这么写
public static void show（String str , int ...arr）
class ParamethodDemo
{
public static void main(String[] args)
{
/*
可变参数
其实就是上一种数组参数的简写形式。
不用每一次都手动的建立数组对象。
只要将要操作的元素作为参数传递即可。
隐式将这些参数封装成了数组。
*/
show(2);
show(2,3,4,5,6);//打印 5
}
public static void show(int...arr)（三个点）
{
//System.out.println(arr);//打印[I@de6ced](数组的哈希值)
System.out.println(arr.length);//打印 1 //这里用length？？？？？不是应该用size吗
}
}
4.静态导入
/*
StaticImport 静态导入。
*/
import java.util.*;
import static java.util.Arrays.*;//导入的是Arrays这个类中的所有静态成员。
import static java.lang.System.*;//导入了system类中所有静态成员。
（输出与不用写System.out,可以直接写out.）
当类名重名时，需要指定具体包名。
当方法重名时，指定具备所属的对象或者类。
class staticImport extends Object
{
public static void main(String[] args)
{
int[] arr = {3,1,5};
sort(arr);
int index = binarySearch(arr ,1); //排完序才能查找，因为用的是二分法
System.out.println(Arrays.toString(arr));//因为extends Object中也有tostring方法，但是不能传参数，先进入object，如果去掉Arrays会报错
当类名重名时，需要指定具体包名。
当方法重名时，指定具备所属的对象或者类。
System.out.println(“Index=”+index);
}
/*
class staticImport
{
public static void main(String[] args)
{
int[] arr = {3,1,5};
Arrays.sort(arr);
int index = Arrays.binarySearch(arr ,1);
System.out.println(Arrays.toString(arr));
System.out.println(“Index=”+index);
}
*/
}
325
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
