java的集合的作用_java的集合

Conllection常用功能

publicboolean add(E e): 把给定的对象添加到当前集合中public voidclear(); 情况集合中所有的元素,但是不删除集合，集合是空而已publicboolean remove(e);把给定的对象在当前的集合中删除，集合中存在则删除并返回true,不存在则返回falsepublicboolean contains(E e);判断当前集合是否含有给定对象publicboolean isEmpty(); 判断当前集合是否给空public intsize();返回集合的元素个数public Object[] toArray() 把集合中的元素，存储到数组中

public classDemonCollection {public static voidmain(String[] args) {//创建集合对象，可以使用多态,接口指向一个实例类

Collection coll = new ArrayList<>();

System.out.println(coll);//重写了toString方法

boolean bl = coll.add("quan");

coll.add("QQQ");

System.out.println(coll);//删除元素

System.out.println(coll.remove("QQQ"));

System.out.println(coll.remove("QQ"));//判断是否包含元素

System.out.println(coll.contains("quan"));//判断是否为空

System.out.println(coll.isEmpty());//集合元素的多少

System.out.println(coll.size());

Object[] arr=coll.toArray();

System.out.println(arr);

coll.clear();

System.out.println(coll.isEmpty());

}

}

结果：

[]

[quan, QQQ]true

false

true

false

1[Ljava.lang.Object;@1b6d3586true

Iterator 迭代器

迭代器用于对集合进行百年来

boolean hasNext() 如果有元素可以迭代，则返回true

判断集合中还有没有下一个元素，如果有则返回true,没有则返回false

E next() 返回迭代的下一个元素。取出集合的下一个元素

Iterator 地带其，是一个接口，我们二u发直接使用，需要使用Iterator

接口的实现对象，获取实现类的方法比较特殊

Conllection 接口中国有一个方法，叫iterator()，这个方法返回的就是迭代器的实现对象

迭代器使用步骤：

使用集合中的方法iterator获取迭代器 实现类对象，使用Iterator接口接受(多态)

使用Iterator 接口中的方法hashnext 判断是否有下一个元素

使用Iterator 接口中的方法next ,取出集合中的下一个元素

注意：

使用集合中的方法创建迭代器的时候，使用Iterator接口接受(多态)

Iterator也有泛型，迭代器的泛型跟着集合走，集合是什么泛型，迭代器就是什么泛型

如果没有元素还进行取出，会返回异常：java.util.NoSuchElementException*/

public classDemon {public static voidmain(String[] args) {

Collection coll = new ArrayList<>();

coll.add("QQQQ");

coll.add("AAA");

coll.add("BBB");

coll.add("DDDD");//多态 接口 实现类对象

Iterator it =coll.iterator();

boolean bl=it.hasNext();

System.out.println(bl);

String st=it.next();

System.out.println(st);//知道长度用for,不知道长度用while

while(it.hasNext()){

System.out.println(it.next());

}

}

}/*true

QQQQ

AAA

BBB

DDDD*/

增强for循环

/*Collection extends Iterable,所有单鞋集合恶斗可以使用增强for

public interface Iterable

实现此接口允许对象成为“for-each loop”语句的目标。

增强for循环，用来遍历结合和数组

格式：

for(集合/数组的数据类型 变量名：集合名/数组名){

sout(变量名)

}*/

public classDemoFor {public static voidmain(String[] args) {

demo01();

demo();

}//遍历集合

private static voiddemo(){

ArrayList arrl = new ArrayList<>();

arrl.add("QQQ");

arrl.add("WWW");

arrl.add("RRR");for(String str:arrl){

System.out.println(str);

}

}//遍历数组

private static voiddemo01(){int [] arr = {1,1,2,3,4};for(inti:arr){

System.out.println(i);

}

}

}/*1

1

2

3

4

QQQ

WWW

RRR*/

List

IndexOutOfBoundsException越界异常：

public classd1 {public static voidmain(String[] args) {

List list = new ArrayList<>();

list.add("a");

list.add("b");

list.add("c");//安装存的方式输出,打印的不是地址,证明重写的toString

System.out.println(list);

list.add(1,"D");

System.out.println(list);//移除a元素,返回移除的元素

System.out.println(list.remove(0));

System.out.println(list);//特换指定索引的元素,并返回所替换的元素内容

System.out.println(list.set(0,"ddd"));

System.out.println(list);//list集合遍历方式

for (int i = 0;i

System.out.println(list.get(i));

}

System.out.println("############");//d迭代器遍历

Iterator it =list.iterator();while(it.hasNext()){

System.out.println(it.next());

}

System.out.println("############");//增强for循环

for(String s :list){

System.out.println(s);

}

}

}

List子类

ArrayList集合：

linkedList集合

/*特点:

底层是一个链表结构,查询慢,增删块

里面包含大量操作单点首位方法,不能用多态

注意:使用LinkedList 集合特有的方法,不能使用多态*/import java.sql.ClientInfoStatus;

import java.util.LinkedList;

import java.util.List;public classLinkListT {public static voidmain(String[] args) {

show1();

show2();

}private static voidshow2(){

LinkedList lisked = new LinkedList<>();

lisked.add("QQ");

lisked.add("DAWI");

lisked.add("UUUU");

String first=lisked.getFirst();

System.out.println(first);

String second=lisked.getLast();

System.out.println(second);

lisked.clear();

}private static voidshow1(){

LinkedList linked = newLinkedList();

linked.add("A");

linked.add("B");

linked.add("C");

System.out.println(linked);

linked.addFirst("ONE");

System.out.println(linked);

linked.addLast("last");

System.out.println(linked);

}

}/*[A, B, C]

[ONE, A, B, C]

[ONE, A, B, C, last]

Vector,认识就好

Vector类实现了可扩展的对象数组。 像数组一样，它包含可以使用整数索引访问的组件。 但是， Vector的大小可以根据需要增长或缩小，以适应在创建Vector之后添加和删除项目。

Set接口

/*set特点:

不允许存储重复元素

没有索引,没有索引的算法不能通过普通for遍历

HashSet特点:

不允许存储重复元素

没有索引,没有索引的算法不能通过普通for遍历

是一个无序的集合,存储元素和取出元素的顺序有可能不一致

底层是一个哈希表结构,查询结构非常块*/

public classDDD1 {public static voidmain(String[] args) {

Set set = new HashSet<>();set.add(21);set.add(3);set.add(4);set.add(21);//使用迭代器遍历

Iterator it = set.iterator();while(it.hasNext()){

System.out.println(it.next());

}

System.out.println("############");for (Integer i:set){

System.out.println(i);

}

}

}/*3

4

21

############

3

4

21*/

HashSet集合存储数据结构—哈希表

/*哈希值:是一个十进制的整数,由系统随机给出

(就是对象的地址值,是一个逻辑地址,是模拟出来得到地址,不是数据实际存储的物理地址)

在Object 类有一个方法,可以获取对象的哈希值

int hashCode()

返回对象的哈希码值。*/

public classHashCode {public static voidmain(String[] args) {//person类默认继承了object类,可以使用hashCode方法

Person person = newPerson();int h1 =person.hashCode();

System.out.println(h1);

Person person2= newPerson();int h2 =person2.hashCode();

System.out.println(h2); toString 源码

//public String toString() {//return getClass().getName() + "@" + Integer.toHexString(hashCode());//}

System.out.println(person);//这里的哈希值是上面哈希值的16进制表示方法

System.out.println(person2);//字符串类的哈希值

String s = new String("abc");

String s1= "abc";

String ss= new String("abc");

System.out.println(s.hashCode());

System.out.println(ss.hashCode());

System.out.println(s1.hashCode());

}

}/*460141958

1163157884

quan.set.Person@1b6d3586

quan.set.Person@4554617c

96354

96354

96354*/

HashSet存储自定义的元素：

//存储自定义类型元素//set集合保证元素唯一://存储的元素,必须重写hashVCode和equals方法

自定义的类：

public classPerson {privateString name;private intage;publicPerson() {

}public Person(String name, intage) {this.name =name;this.age =age;

}publicString getName() {returnname;

}public voidsetName(String name) {this.name =name;

}public intgetAge() {returnage;

}public void setAge(intage) {this.age =age;

}

@OverridepublicString toString() {return "Person{" +

"name='" + name + '\'' +

", age=" + age +

'}';

}

@Overridepublicboolean equals(Object o) {if (this == o) return true;if (o == null || getClass() != o.getClass()) return false;

Person person=(Person) o;return age == person.age &&Objects.equals(name, person.name);

}

@Overridepublic inthashCode() {returnObjects.hash(name, age);

}

}

hashset储存：

public classSetPerson {//要求同名同年龄的人,视为同一个人,只能村一次

public static voidmain(String[] args) {

HashSet hp = new HashSet<>();

Person p1= new Person("quan",22);

Person p2= new Person("quan",22);

Person p3= new Person("quan",11);

System.out.println(p1.hashCode());

System.out.println(p2.hashCode());

hp.add(p1);

hp.add(p2);

hp.add(p3);

System.out.println(hp);

}

}/*107941030

107941030

[Person{name='quan', age=11}, Person{name='quan', age=22}]*/

LinkedHashSet

/*java.util.LinkedHashSet集合 extends HashSet集合

LinkedHashSet集合提点:

底层是一个哈希表(数组+链表/红黑树)+链表

多了一个链表(就hi了元素的存储顺序),保证元素有序*/

public classLinkHashSet {public static voidmain(String[] args) {

HashSet set = new HashSet<>();set.add("www");set.add("abc");set.add("quan");set.add("abc");

System.out.println(set);//不允许重复,无序

LinkedHashSet linkedset = new LinkedHashSet<>();

linkedset.add("www");

linkedset.add("abc");

linkedset.add("quan");

linkedset.add("abc");

System.out.println(linkedset);//不允许重复,有序

}

}

操作集合的工具

/*sort方法的使用前提,

对排序的集合里面必须实现Comparable ,重写定义排序的规则

Comparable的排序规则

自己(this) - 参数:升序*/

public classDemo {public static voidmain(String[] args) {

ArrayList list = new ArrayList<>();//集合加入多个元素,因为addALL是静态方法

Collections.addAll(list,"A","tt","b","uu","B");

System.out.println(list);//打乱顺序,打乱集合的顺序

Collections.shuffle(list);

System.out.println(list);//自然排序

Collections.sort(list);

System.out.println(list);

ArrayList listInt = new ArrayList<>();

listInt.add(22);

listInt.add(21);

listInt.add(12);

listInt.add(42);

System.out.println(listInt);//sort list> 将集合中的元素安装默认规则排序

Collections.sort(listInt);//默认是升序排序

System.out.println(listInt);

ArrayList personlist = new ArrayList<>();

personlist.add(new Person("AA",12));

personlist.add(new Person("BB",9));

personlist.add(new Person("CC",82));

System.out.println(personlist);

Collections.sort(personlist);

System.out.println(personlist);

}

}

结果：

[A, tt, b, uu, B]

[A, B, b, tt, uu]

[A, B, b, tt, uu]

[22, 21, 12, 42]

[12, 21, 22, 42]

[Person{name='AA', age=12}, Person{name='BB', age=9}, Person{name='CC', age=82}]

[Person{name='BB', age=9}, Person{name='AA', age=12}, Person{name='CC', age=82}]

其中Person类:

package quan.kebvian;public class Person implements Comparable{privateString name;private intage;publicPerson() {

}public Person(String name, intage) {this.name =name;this.age =age;

}

@OverridepublicString toString() {return "Person{" +

"name='" + name + '\'' +

", age=" + age +

'}';

}publicString getName() {returnname;

}public voidsetName(String name) {this.name =name;

}public intgetAge() {returnage;

}public void setAge(intage) {this.age =age;

}

@Overridepublic intcompareTo(Person o) {//return 0;表示元素都是相同的//自定义比较的规则,比较两个人的年龄//return .getAge() - this.getAge();//年龄降序序排序

return this.getAge() - o.getAge();//年龄升序排序

}

}

Comparator和Comparable的区别

/*Comparable:自己(this)和别人(参数)比较,自己需要实现Comparable接口,重写比较规则

Comparator: 相当于找一个第三方的裁判,比较两个

Comparator 的排序规则

o1 -o2 升序*/

public classComparator {public static voidmain(String[] args) {

ArrayList listInt = new ArrayList<>();

listInt.add(22);

listInt.add(21);

listInt.add(12);

listInt.add(42);

System.out.println(listInt);

Collections.sort(listInt,new java.util.Comparator() {

@Overridepublic intcompare(Integer o1, Integer o2) {return o1 -o2;

}

});

System.out.println(listInt);

System.out.println("@@@@@@@@@@@@@@@@@");

ArrayList personlist = new ArrayList<>();

personlist.add(new Person("AA",12));

personlist.add(new Person("BB",90));

personlist.add(new Person("CC",12));

personlist.add(new Person("DD",9));

System.out.println(personlist);

Collections.sort(personlist,new java.util.Comparator() {

@Overridepublic intcompare(Person o1, Person o2) {return o1.getAge() -o2.getAge();

}

});

System.out.println(personlist);

Collections.sort(personlist,new java.util.Comparator() {

@Overridepublic intcompare(Person o1, Person o2) {int re = o1.getAge() -o2.getAge();//如果两个人的年龄相同,再使用姓名的首字母比较

if (re == 0){

re= o1.getName().charAt(0) -o2.getName().charAt(0);

}returnre;

}

});

System.out.println(personlist);

}

}

[22, 21, 12, 42]

[12, 21, 22, 42]

@@@@@@@@@@@@@@@@@

[Person{name='AA', age=12}, Person{name='BB', age=90}, Person{name='CC', age=12}, Person{name='DD', age=9}]

[Person{name='DD', age=9}, Person{name='AA', age=12}, Person{name='CC', age=12}, Person{name='BB', age=90}]

[Person{name='DD', age=9}, Person{name='AA', age=12}, Person{name='CC', age=12}, Person{name='BB', age=90}]