黑马程序员_Java学习日记第五天--集合
List:特有方法。凡是可以操作角标的方法都是该体系特有的方法。
增
add(index,element);
addAll(index,Collection);
删
remove(index);
改
set(index,element)
查
get(index)
sublist(from,to)
listIterator();
List集合特有的迭代器ListIterator是Iterator的子接口。
在迭代时，不可以通过集合的方法访问集合中的内容，否则会发生ConcurrentModificationException异常
所以在迭代时只能用迭代器的方法操作元素，可是Iterator的方法是有限的，只能对元素进行判断、取出、删除的操作
如果想要其他的操作，如添加、修改等，就必须通过list的子接口ListIterator
该接口只能通过list集合的ListIterator方法获取
ListIterator(在遍历过程中可以进行增删改查)
List集合方法使用举例：
import java.util.*;
publicclassTestDemo {
publicstaticvoid method()
{
ArrayListal=new ArrayList();
al.add("s1");
al.add("s2");
al.add("s3");
al.add(0,"s2");//在指定位置添加元素，相当于插入
//al.remove(1);
al.set(1,"s7");//改指定位置的值
ArrayListnewal=new ArrayList();
newal.add("n1");
al.addAll(newal);//添加集合
System.out.println(al.get(2));
//通过for循环访问list集合元素
for(int x=0;x
{
System.out.println("al["+x+"]="+al.get(x));
}
//Iterator迭代器
Iteratorit=al.iterator();
while(it.hasNext())
{
System.out.println(it.next());
}
//通过indexof获取对象的位置
System.out.println(al.indexOf("s2"));
Listsub=al.subList(1, 2); //包括头不包括尾
System.out.println("sub="+sub);
}
publicstaticvoid main(String[] args) {
method();
ArrayListal=new ArrayList();
al.add("s1");
al.add("s2");
al.add("s3");
/*
Iteratorit=al.iterator();
while(it.hasNext())
{
al.add("s4");//不能在迭代器中使用集合的添加方法，会导致发生ConcurrentModificationException并发修改异常
System.out.println(it.next());
}
*/
//在迭代过程中，添加或删除元素
ListIteratorli=al.listIterator();
while(li.hasNext())
{
Objectobj=li.next();
if(obj.equals("s1"))
{li.add("S10");
//li.set("S10");
}
}
System.out.println(al);
//逆向遍历
while(li.hasPrevious())
{System.out.print(li.previous()+" ");}
}
}
运行结果是：s2
al[0]=s2
al[1]=s7
al[2]=s2
al[3]=s3
al[4]=n1
s2
s7
s2
s3
n1
0
sub=[s7]
[s1, S10, s2, s3]
s3 s2 S10 s1
Linkedlist特有方法：
增
addFirst();
addLast();
查
getFirst();
getLast();
获取元素，但不删除元素。如果集合中没有元素，会出现NoSuchElementException
删
removeFirst();
removeLast();
获取元素，但是元素被删除，如果集合中没有元素，会出现NoSuchElementException
1.6出现的新方法
offerFirst();
offerLast();
peekFirst();
peekLast();
获取元素，但不删除元素。如果集合中没有元素，会返回null。
pollFirst();
pollLast();
获取元素，但是元素被删除，如果集合中没有元素，会返回null。
堆栈：先进后出
队列：先进先出
模拟队列代码：
import java.util.*;
publicclassDuiLieDemo {
publicstaticvoid main(String[] args)
{
DuiLiedl=newDuiLie();
dl.MyAdd("zh1");
dl.MyAdd("zh2");
dl.MyAdd("zh3");
while(!dl.isNull())
{
System.out.println(dl.MyGet());
}
}
}
class DuiLie
{
private LinkedListlink;
DuiLie()
{
link=new LinkedList();
}
publicvoid MyAdd(Object obj)
{
link.addFirst(obj);
}
public Object MyGet()
{
returnlink.removeLast();
}
publicboolean isNull()
{
returnlink.isEmpty();
}
}
ArrayList练习（集合的元素是学生对象，并去除相同元素）
import java.util.*;
//List集合判断元素是否相同依据的是元素的equals方法。
publicclass ArrayListTest
{
publicstaticvoid main(String[] args) {
ArrayList al=new ArrayList();
al.add(new student("lisi1",26));
al.add(new student("lisi2",27));
al.add(new student("lisi3",28));
al.add(new student("lisi2",27));
al.add(new student("lisi4",29));
al=singleElement(al);
al.remove(new student("lisi2",27));//调用对象的equals方法
Iterator it=al.iterator();
while(it.hasNext())
{
studentstu=(student)it.next();
sop(stu.getName()+"::"+stu.getAge());
}
}
publicstaticvoid sop(Object obj)
{
System.out.println(obj);
}
publicstatic ArrayList singleElement(ArrayList al)
{
ArrayList newal=new ArrayList();
Iterator it=al.iterator();
while(it.hasNext())
{
Object obj=it.next();
if(!newal.contains(obj))
newal.add(obj);
}
return newal;
}
}
class student
{
private Stringname;
privateintage;
student(Stringname,int age)
{
this.name=name;
this.age=age;
}
//覆盖父类Object中的equals方法
public boolean equals(Object obj)
{
if(!(objinstanceof student))
return false;
student stu=(student)obj;
returnthis.name.equals(stu.name)&&this.age==stu.age;
}
public String getName()
{
returnname;
}
publicint getAge()
{
returnage;
}
}
|--List:元素是有序的，元素可以重复，因为该集合体系有索引。
|--ArrayList：底层的数据结构使用的是数组数据结构。特点：查询速度很快，但是增删稍慢。线程不同步，效率高。
|--LinkedList：底层使用的是链表数据结构。特点：增删速度很快，查询稍慢
|--Vector:底层是数组数据结构。线程同步（Vector类多了一种特有的的元素取出方式Enumeration，现已被Itearator代替）
|--Set:元素是无序的(存入和取出的顺序不一定一致)，元素不可以重复。
|--HashSet:底层数据结构是哈希表。
Hashset是如何保证元素唯一性的呢？
是通过元素的两个方法，hashcode和equals来完成的
如果元素的Hashcode值相同，才会判断equals是否为true。
如果元素的Hashcode值不同，不会调用equals.
注意：对于判断元素是否存在，以及删除等操作，依据的方法是元素的hashcode和equals方法。
|--TreeSet：可以对Set集合中的元素进行排序。
底层数据结构是二叉树。
保证元素唯一性的依据：
compareTo return 0.
TreeSet排序的第一种方式：让元素自身具备比较性。
元素需要实现Comparable接口，覆盖compareTo方法。
这种方式也称为元素的自然顺序，或者叫做默认顺序。
Comparabel接口实现举例：
import java.util.*;
publicclassTreeSet_comparable {
publicstaticvoid main(String[] args) {
TreeSet ts=new TreeSet();
ts.add(new Person("lisi1",26));
ts.add(new Person("lisi2",27));
ts.add(new Person("lisi3",28));
ts.add(new Person("lisi2",28));
ts.add(new Person("lisi2",27));
ts.add(new Person("lisi1",29));
Iterator it=ts.iterator();
while(it.hasNext())
{
Person p=(Person)it.next();
System.out.println(p.getName()+"------"+p.getAge());
}
}
}
class Personimplements Comparable
{
private Stringname;
privateintage;
Person(String name,int age)
{
this.name=name;
this.age=age;
}
//覆盖父类Object中的equals方法
publicintcompareTo(Object obj) //这里传进来的对象必须是Object的，否则不算覆盖
{
if(!(objinstanceof Person))
thrownew RuntimeException("不是人对象");
Personpe=(Person)obj;
if(this.age>pe.age)
return 1;
if(this.age==pe.age)
{
returnthis.name.compareTo(pe.name);//年龄相同则比较姓名
}
elsereturn -1;
}
public String getName()
{
returnname;
}
publicintgetAge()
{
returnage;
}
}
TreeSet的第二种排序方式。
当元素自身不具备比较性时，或者具备的比较性不是所需要的。
这时就需要让集合自身具备比较性，在集合初始化时，就有了比较方式。
定义一个比较器，将比较器对象作为参数传递给TreeSet集合的构造函数。
当两种排序都存在时，以比较器为主。
定义比较器：定义一个类，实现Comparator接口，覆盖compare方法。
TreeSet实现Comparator接口排序举例：
import java.util.*;
publicclassTreeSet_Comparator {
publicstaticvoid main(String[] args) {
TreeSet ts=new TreeSet(new MyCompare());
ts.add(new Person("lisi1",26));
ts.add(new Person("lisi2",27));
ts.add(new Person("lisi3",28));
ts.add(new Person("lisi5",28));
ts.add(new Person("lisi2",28));
ts.add(new Person("lisi4",29));
Iterator it=ts.iterator();
while(it.hasNext())
{
Person p=(Person)it.next();
System.out.println(p.getName()+"------"+p.getAge());
}
}
}
class MyCompareimplements Comparator
{
publicint compare(Object o1,Objecto2)
{
Personp1=(Person)o1;
Personp2=(Person)o2;
int i=p1.getName().compareTo(p2.getName());
if(i==0)
returnp1.getAge()-p2.getAge();
return i;
}
}
|--Map
|--Hashtable:底层是哈希表数据结构，不可以存入null键null值，该集合是线程同步的。
|--HashMap:底层是哈希表数据结构，允许使用null键和null值，该集合是不同步的。
|--Treemap:底层是二叉树数据结构，线程不同步，可以用于给map集合中的键排序。
Map集合：该集合存储键值对，一对一对往里存，而且要保证键的唯一性
1.添加
put(Kkey,V value)
putAll(Map m)
2.删除
clear()
remove(Objectkey)
3.判断
containsValue(Objectvalue)
containsKey(Objectkey)
isEmpty()
4.获取
get(Objectkey)
size()
value()
entrySet()
keySet()
HashMap:；如果出现添加值到相同的键上，后添加的值会覆盖先添加的值，并且put键返回该键原来对应的值。
Map集合的两种取出方式：
1. keySet:将map中所有的键存入到set集合，因为set具备迭代器。
所以可用迭代方式取出所有的键，再根据get方法，获取每一个键对应的值。Map.get(key);
Map集合的取出原理，将map集合转成set集合，再通过迭代器取出。
2.Set<>entrySet;
Map.Entry：其实Entry也是一个接口，它是Map接口中的一个内部接口。
Set
所以可用迭代方式取出所有的键，再根据get方法，获取每一个键对应的值。
Set
HashMap的两种元素取出方式代码举例：
import java.util.*;
publicclassMapDemo {
publicstaticvoid main(String[] args) {
HashMap
m.put(new student2("zhangsan",18),"BeiJing");
m.put(new student2("lisi",19),"HongKong");
m.put(new student2("lisi",19),"TianJin");
m.put(new student2("wangwu",28),"TaiWan");
m.put(new student2("tanqi",38),"AoMen");
Set
Iteratorit=key.iterator();
while(it.hasNext())
{
student2stu=(student2)it.next();
System.out.println(stu.getName()+" "+stu.getAge()+" years old,comes from "+m.get(stu));
}
Set
Iterator
while(entit.hasNext())
{
Map.Entry
student2s=me.getKey();
Stringaddr=me.getValue();
System.out.println(s.getName()+" "+s.getAge()+" "+"---"+addr);
}
}
}
class student2implements Comparable
{
private Stringname;
privateintage;
student2(Stringname,intage)
{
this.name=name;
this.age=age;
}
publicint compareTo(student2 s)//实现比较性
{
int num=new Integer(this.age).compareTo(s.age);
if(num==0)
returnthis.name.compareTo(s.name);
return num;
}
public String getName()
{
returnname;
}
publicint getAge()
{
returnage;
}
publicint hashCode()//复写hashCode和equals方法
{
returnname.hashCode()+age*35;
}
publicboolean equals(Object obj)
{
if(!(objinstanceof student2))
thrownew ClassCastException("元素类型不匹配！");
student2stu=(student2)obj;
returnthis.name.equals(stu.name)&&this.age==stu.age;
}
}
运行结果：lisi19 years old,comes from TianJin
tanqi 38 years old,comes from AoMen
zhangsan 18 years old,comes fromBeiJing
wangwu 28 years old,comes fromTaiWan
lisi 19 ---TianJin
tanqi 38 ---AoMen
zhangsan 18 ---BeiJing
wangwu 28 ---TaiWan
注意：将数组变成集合，不可以使用集合的增删方法，因为数组的长度是固定的。
Contains,get,indexOf(),subList()可以使用。
如果你增删，那么会发生UnsupportedOperationException。
如果数组中的元素是对象，那么变成集合时，数组中的元素就直接转成集合中的元素。
如果数组中的元素都是基本数据类型，那么会将该数组作为集合中的元素存在。
Arrays使用举例：
import java.util.*;
publicclassArraysDemo {
publicstatic void main(String[] args) {
int []arr={1,2,6};
System.out.println(Arrays.toString(arr));
List list = Arrays.asList(arr);//如果数组的数据为基本数据类型，则将数组//转换成集合时，将整个数组作为集合的一个元素
System.out.println(list);
Integer[]in={1,2,6};
Listli=Arrays.asList(in);
li.set(1,9);//add和remove方法不能使用，因为数组的长度是固定的。
System.out.println(li);
}
}
集合变数组
1.指定类型的数组到底要定义多长呢？
当指定类型的数组长度小于了集合的size,那么该方法内部会创建一个新的数组，长度为集合的size。
当指定类型的数组长度大于了集合的size，就不会新创建数组，而是使用传递进来的数组。
所以创建一个刚刚好的数组最优。
为什么要将集合变数组？
为了限定对元素的操作，不允许对数据进行增删。
集合变数组举例：
import java.util.*;
publicclassCollectionToArray {
publicstaticvoid main(String[] args) {
ArrayList
al.add("zhangsan1");
al.add("zhangsan2");
al.add("zhangsan3");
String[]str=al.toArray(newString [al.size()]);
System.out.println(Arrays.toString(str));
}
}
Date 将模式封装到SimpleDateFormat对象中。
调用format方法让模式格式化指定Date对象。
Data对象方法举例：
import java.text.*;
import java.util.*;
publicclassDataDemo {
publicstaticvoidmain(String[] args)throws Exception
{
Date d=new Date();
System.out.println(d);
SimpleDateFormat dsf=new SimpleDateFormat("yyyy年MM月dd日Ekk时mm分ss秒");
String time=dsf.format(d);
System.out.println(time);
}
}
Calendar类
方法调用举例：（从键盘录入获取任一年份值，求出该年份的二月有多少天）
import java.io.*;
import java.text.*;
import java.util.*;
publicclassCalendarDemo {
publicstaticvoid main(String[] args)throws Exception
{
Calendarc=Calendar.getInstance();
while(true)
{
BufferedReaderbuf=newBufferedReader(newInputStreamReader(System.in));
Stringstr=buf.readLine();
if(!str.equals("over"))
{
int ye=Integer.parseInt(str);
c.set(ye,2,1);
c.add(Calendar.DAY_OF_MONTH, -1);
Dated=c.getTime();
SimpleDateFormatsdf=newSimpleDateFormat("yyyy年MM月，共有dd日");
Stringtime=sdf.format(d);
System.out.println(time);
continue;
}
break;
}
}
}
Math
Ceil返回大于等于指定数据的最小整数
Floor返回小于等于指定数据的最大整数
Round四舍五入
Pow幂运算 pow(a,b)
Math类方法举例：
import java.util.Random;
publicclassMathDemo {
publicstaticvoid main(String[] args) {
Randomr=newRandom();//两种生成随机数的方法
for(int x=0;x<10;x++)
{
int d=r.nextInt(10)+1;//不需强转类型
System.out.println(d);
}
for(int x=0;x<10;x++)
{
double d=(int)(Math.random()*10+1);
System.out.println(d);
}
test();
}
publicstaticvoid test()
{
double d=Math.abs(-7);
double d1=Math.ceil(17.28);//返回大于给定数的最小整数
double d2=Math.floor(17.28);//返回小于给定数的最大整数
double d3=Math.pow(3,3);//3的3次方
double d4=Math.round(12.30);//四舍五入
System.out.println(d);
System.out.println(d1);
System.out.println(d2);
System.out.println(d3);
System.out.println(d4);
}
}
List、Map、Set三个接口，存取元素时，各有什么特点？
首先，List与Set具有相似性，它们都是单列元素的集合，所以，它们有一个共同的父接口，叫Collection。Set里面不允许有重复的元素，所谓重复，即不能有两个相等（注意，不仅仅是相同）的对象 ，即假设Set集合中有了一个A对象，现在我要向Set集合再存入一个B对象，但B对象与A对象equals相等，则B对象存储不进去，所以，Set集合的add方法有一个boolean的返回值，当集合中没有某个元素，此时add方法可成功加入该元素时，则返回true，当集合含有与某个元素equals相等的元素时，此时add方法无法加入该元素，返回结果为false。Set取元素时，没法说取第几个，只能以Iterator接口取得所有的元素，再逐一遍历各个元素。
List表示有先后顺序的集合， 注意，不是那种按年龄、按大小、按价格之类的排序。当我们多次调用add(Object)方法时，每次加入的对象就像火车站买票有排队顺序一样，按先来后到的顺序排序。有时候，也可以插队，即调用add(int index,Object)方法，就可以指定当前对象在集合中的存放位置。一个对象可以被反复存储进List中，每调用一次add方法，这个对象就被插入进集合中一次，其实，并不是把这个对象本身存储进了集合中，而是在集合中用一个索引变量指向这个对象，当这个对象被add多次时，即相当于集合中有多个索引指向了这个对象，如图x所示。List除了可以以Iterator接口取得所有的元素，再逐一遍历各个元素之外，还可以调用get(index i)来明确说明取第几个。 Map与List和Set不同，它是双列的集合，其中有put方法，定义如下：put(obj key,obj value)，每次存储时，要存储一对key/value，不能存储重复的key，这个重复的规则也是按equals比较相等。取则可以根据key获得相应的value，即get(Object key)，返回值为key 所对应的value。另外，也可以获得所有的key的集合，还可以获得所有的value的集合，还可以获得key和value组合成的Map.Entry对象的集合。List 以特定次序来持有元素，可有重复元素。Set 无法拥有重复元素,内部排序。Map 保存key-value值，value可多值。
HashSet按照hashcode值的某种运算方式进行存储，而不是直接按hashCode值的大小进行存储例如，"abc" ---> 78，"def" ---> 62，"xyz" ---> 65在hashSet中的存储顺序不是62,65,78。LinkedHashSet按插入的顺序存储，那被存储对象的hashcode方法还有什么作用呢？hashset集合比较两个对象是否相等，首先看hashcode方法是否相等，然后看equals方法是否相等。new 两个Student插入到HashSet中，看HashSet的size，实现hashcode和equals方法后再看size。同一个对象可以在Vector中加入多次。往集合里面加元素，相当于集合里用一根绳子连接到了目标对象。往HashSet中却加不了多次的。
------ android培训、 java培训、期待与您交流！ ----------