集合的一些概念(1)

2019独角兽企业重金招聘Python工程师标准>>>

*collection

|--List:元素师有序的，元素师可以重复的，因为该集合有索引。

         |--ArrayList（jdk1.2）:底层的数据结构使用的是数组结构。特点：查询速度很快，但是增删稍慢，线程是不同步的。删除，判断元素是否存在只依赖equals方法

                                     默认实例化一个ArrayList，产生十个空列表，以后50%的添加

             |--LinkedList：底层使用的是链表数据结构。特点：查询很慢，但是增删很快

         |--vector:底层是数组数据结构，线程同步。被ArrayList替代。

      默认产生10个空列表，100%添加，浪费资源空间 

                                                       ----iterator和vector的区别，vector支持枚举，而iterator不支持

|--set:元素师无序的（存入和取出的顺序不一定一致），元素不可以重复。 set集合的功能和collection一致

        |--hashSet ：底层数据结构是哈希表，线程非同步

              hashSet是如何保证元素的唯一性的呢？

              是通过元素的两个方法，重写hashCode和equals是否为true

              如果元素的hashCode值不同，才会调用equals

              注意，对于判断元素是否存在，以及删除等操作，依赖元素的hashcode 和equals方法

        |--treeSet：可以对set集合中的元素进行排序，按照字母的自然顺序进行排序

            底层数据结构是二叉树，保证数据的唯一性的依据：compareTo方法return  0，就是相同的，则无法存入集合

             treeSet排序的第一种方式：让元素自身具备比较性

              元素需要实现CompareTo接口，覆盖CompareTo方法

               这种方法也成为元素的自然顺序，或者叫做默认顺序

               TreeSet的第二种排序方式。

                当元素自身不具备比较性，或者具备的比较性不是所需要的

                                                             这时就需要让容器自身具备比较性 

               在集合初始化时，就有了比较方式

               

                当两种排序都存在时，以比较器为主

Comparable 包里有compareTo方法

               怎样定义一个比较器： 1.实现Comparator接口，覆盖Compare方法

                                                            用0来判断是否元素相同     

*collection

|--List:元素师有序的，元素师可以重复的，因为该集合有索引。

         |--ArrayList（jdk1.2）:底层的数据结构使用的是数组结构。特点：查询速度很快，但是增删稍慢，线程是不同步的。删除，判断元素是否存在只依赖equals方法

                                     默认实例化一个ArrayList，产生十个空列表，以后50%的添加

             |--LinkedList：底层使用的是链表数据结构。特点：查询很慢，但是增删很快

         |--vector:底层是数组数据结构，线程同步。被ArrayList替代。

      默认产生10个空列表，100%添加，浪费资源空间 

                                                       ----iterator和vector的区别，vector支持枚举，而iterator不支持

|--set:元素师无序的（存入和取出的顺序不一定一致），元素不可以重复。 set集合的功能和collection一致

        |--hashSet ：底层数据结构是哈希表，线程非同步

              hashSet是如何保证元素的唯一性的呢？

              是通过元素的两个方法，重写hashCode和equals是否为true

              如果元素的hashCode值不同，才会调用equals

              注意，对于判断元素是否存在，以及删除等操作，依赖元素的hashcode 和equals方法

        |--treeSet：可以对set集合中的元素进行排序，按照字母的自然顺序进行排序

            底层数据结构是二叉树，保证数据的唯一性的依据：compareTo方法return  0，就是相同的，则无法存入集合

             treeSet排序的第一种方式：让元素自身具备比较性

              元素需要实现CompareTo接口，覆盖CompareTo方法

               这种方法也成为元素的自然顺序，或者叫做默认顺序

*TreeSet按照姓名排序,自定义一个比较器（按姓名排序）

public 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 void setName(String name) {

this.name = name;

}

public int getAge() {

return age;

}

public void setAge(int age) {

this.age = age;

}

@Override

public int compareTo(Object obj) {

if (!(obj instanceof Student))

throw new RuntimeException("不是学生对象");

Student s = (Student) obj;

// System.out.println(this.name+"...compareto..."+s.name);

if (this.age > s.age) {

return 1;

}

if (this.age == s.age) {

this.name.compareTo(s.name);

}

return -1;

}

}

import java.util.Iterator;

import java.util.TreeSet;

public class Studentdemo {

public static void main(String[] args) {

TreeSet ts=new TreeSet();

ts.add(new Student("lisi01",22));

ts.add(new Student("lisi001",14));

ts.add(new Student("lisi0hj1",25));

ts.add(new Student("lisigh01",74));

ts.add(new Student("lisigh01",2));

Iterator it=ts.iterator();

while(it.hasNext()){

Student str=(Student)it.next();

System.out.println(str.getName()+",,,"+str.getAge());

}

}

}

import java.util.Comparator;

public class MyCompare implements Comparator{

@Override

public int compare(Object o1, Object o2) {

Student s1=(Student)o1;

Student s2=(Student)o2;

//第一种方式

                 //  return s1.getName().compareTo(s2.getName());

//第二种方式

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 new Integet(s1.getAge()).compareTo(new Integer(s2.getAge()));

}

return num;

}

}

}

*jdk1.0    之后有的Vector：特有的方法添加元素：Elements（）。。。

                                                                 ---- hasNextElement()返回Enumeration接口

                                                                  --- nextElement()

  ----枚举就是Vector特有的取出方式

---枚举和迭代器（iterator）很像，是一样的

---因为枚举的名称和方法的名称都过长，被迭代器所取代，枚举就消失了

          ----iterator和vector的区别，vector支持枚举，而iterator不支持

*linkedlist

                  - ---线程不同步

                  ---- 特有方法             addFirst（），添加头---->offerFirst()

                          addLast（），添加尾---->offerLast()

                            getFirst（），得到头---->peekFirst()    jdk1.6

                          getLast（），得到尾---->peekLast()

get获取元素但是不删除元素, 如果集合中没有元素,则会抛出NoSuchElemntException异常,jdk1.6则会返回null

                            removeFirst（），删除头--->poolFirst()

                                                removeLast（），删除尾--->poolLast()

  remove取出元素，删除元素.如果集合中没有元素,则会抛出NoSuchElemntException异常，jdk1.6则会返回null

                ----用addfirst（）方法向集合中添加元素，越晚放进集合，打印出的位置月在前面

                    addLast（）则相反

                -- --linkedlist 不用迭代器，遍历集合

linkedList link=new  linkedList();

while（！link .isEmpty()）{

system.out.println(link.remove);

}

                

----使用LinkedList模拟一个堆栈或者队列的数据结构

 堆栈：先进后出，如同一个杯子

  public class Duilie {

private LinkedList link;

Duilie() {

link = new LinkedList();

}

public void myAdd(Object obj){

link.addLsat(obj);

}

public Object myGet(){

return link.removeFirst();

}

public boolean isNull(){

return link.isEmpty();

}

}

public class Test {

public static void main(String[] args) {

Duilie d=new Duilie();

d.myAdd("1");

d.myAdd("2");

d.myAdd("3");

d.myAdd("4");

while(!d.isNull()){

System.out.println(d.myGet());

}

}

}

 队列：先进先出，如同一个水管

  public class Duilie {

private LinkedList link;

Duilie() {

link = new LinkedList();

}

public void myAdd(Object obj){

link.addFirst(obj);

}

public Object myGet(){

return link.removeLast();

}

public boolean isNull(){

return link.isEmpty();

}

}

public class Test {

public static void main(String[] args) {

Duilie d=new Duilie();

d.myAdd("1");

d.myAdd("2");

d.myAdd("3");

d.myAdd("4");

while(!d.isNull()){

System.out.println(d.myGet());

}

}

}

   

*ArrayList

----去除ArrayList中的重复元素（ 要定义一个新临时容器）

        public class ArrayListTest {

public static void sop(Object obj){

System.out.println(obj);

}

public static void main(String[] args) {

ArrayList al=new ArrayList();

al.add("1");

al.add("2");

al.add("2");

al.add("1");

al.add("1");

al.add("1");

sop(al);

al=SingleElement(al);

sop(al);

}

public static ArrayList SingleElement(ArrayList al){

ArrayList newA1=new ArrayList();

Iterator it=al.iterator();

while(it.hasNext()){

Object obj=it.next();

if(!newA1.contains(obj)){

newA1.add(obj);

}

}

return newA1;

}

}

         ----在迭代时循环中next调用一次，就要hasnext判断一次

----将自定义对象作为元素存到ArrayList集合 中，并去除重复元素，存人，同姓名，同年龄视为同一个人，为重复元素

             1.对人描述，将数据封装进对象

             2.定义容器，将人存入

           List集合判断元素是否相同，依据的是元素的equals方法

public class Person {

private String name;

private int age;

public Person(String name,int age){

this.name=name;

this.age=age;

}

public String getName() {

return name;

}

public void setName(String name) {

this.name = name;

}

public int getAge() {

return age;

}

public void setAge(int age) {

this.age = age;

}

public boolean equals(Object obj){

if(!(obj instanceof Person))

return false;

Person p=(Person)obj;

System.out.println(this.name+",,,"+p.name);

return this.name.equals(p.name)&&this.age==p.age;

}

}

import java.util.ArrayList;

import java.util.Iterator;

public class PersonTest {

public static void sop(Object obj){

System.out.println(obj);

}

public static void main(String[] args) {

ArrayList al=new ArrayList();

al.add(new Person("lisi01",30));

al.add(new Person("lisi02",32));

al.add(new Person("lisi02",32));

al.add(new Person("lisi03",33));

al.add(new Person("lisi04",35));

al.add(new Person("lisi04",35));

al=SingleElement(al);

Iterator it=al.iterator();

while(it.hasNext()){

Person p=(Person)it.next();

sop(p.getName()+"::"+p.getAge());

}

}

public static ArrayList SingleElement(ArrayList al){

ArrayList newA1=new ArrayList();

Iterator it=al.iterator();

while(it.hasNext()){

Object obj=it.next();

if(!newA1.contains(obj)){

newA1.add(obj);

}

}

return newA1;

}

}

*往hashSet中存入自定义的对象

   姓名和年龄相同为一个人，重复元素

public class Persona {

private String name;

private int age;

Persona(String name, int age) {

this.name = name;

this.age = age;

}

public String getName() {

return name;

}

public void setName(String name) {

this.name = name;

}

public int getAge() {

return age;

}

public void setAge(int age) {

this.age = age;

}

public int hashCode(){

System.out.println(this.name+"....hs=ashCode");

return  name.hashCode()+age*37;

}

public boolean equals(Object obj) {

if (!(obj instanceof Persona))

return false;

Persona p = (Persona) obj;

System.out.println(this.name + ",,," + p.name);

return this.name.equals(p.name) && this.age == p.age;

}

}

import java.util.HashSet;

import java.util.Iterator;

public class Demo {

public static void sop(Object obj){

System.out.println(obj);

}

public static void main(String[] args) {

HashSet hs=new HashSet();

hs.add(new Persona("a1",11));

hs.add(new Persona("a2",15));

hs.add(new Persona("a3",133));

hs.add(new Persona("a3",133));

hs.add(new Persona("a4",00));

hs.add(new Persona("a4",00));

Iterator it=hs.iterator();

while(it.hasNext()){

Persona p=(Persona)it.next();

sop(p.getName()+"::"+p.getAge());

}

}

}

*treeSet（传入里面的对象必须具有比较性）

需求：往treeSet集合中存储自定义对象学生

              想按照学生的年龄进行排序

记住：当主要条件相同时，一定判断一下次要条件

import javax.management.RuntimeException;

public 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 void setName(String name) {

this.name = name;

}

public int getAge() {

return age;

}

public void setAge(int age) {

this.age = age;

}

@Override

public int compareTo(Object obj) {

/*

if(!(obj instanceof Student))

throw new RuntimeException( "不是学生对象");

Student s=(Student)obj;

System.out.println(this.name+"...compareto..."+s.name);

if(this.age>s.age){

this.name.compareTo(s.name);

}

if(this.age==s.age){

 

}

return -1;

*/

return 1; 

}

}

import java.util.Iterator;

import java.util.TreeSet;

public class Studentdemo {

public static void main(String[] args) {

TreeSet ts=new TreeSet();

ts.add(new Student("lisi01",22));

ts.add(new Student("lisi001",14));

ts.add(new Student("lisi0hj1",25));

ts.add(new Student("lisigh01",74));

ts.add(new Student("lisigh01",2));

Iterator it=ts.iterator();

while(it.hasNext()){

Student str=(Student)it.next();

System.out.println(str.getName()+",,,"+str.getAge());

}

}

}

练习：按照字符串长度排序

字符串本身具备比较性。但是它的比较方式不是所需要的

这是就只能使用比较器

转载于:https://my.oschina.net/u/258043/blog/73394