黑马程序员_集合

最新推荐文章于 2022-11-30 21:20:11 发布

u011104495

最新推荐文章于 2022-11-30 21:20:11 发布

阅读量408

点赞数

本文链接：https://blog.csdn.net/u011104495/article/details/17556293

版权

------- 物联云培训、java培训、期待与您交流！ ----------

集合：

List集合：

一．集合类的特点

集合用于存储不同类型的对象，集合的长度是可变的。

二．集合框架

Collection接口

List接口:可以有重复元素，元素是有序的。

ArrayList：底层是数组，查找元素比较容易，添加元素稍微慢

LinkedList：底层是链表，查找元素比较慢，添加元素比较容易

Vector：线程比较安全，但是速度慢，已经被ArrayList取代了

Set接口：set集合底层调用的是Map集合

HashSet：底层是哈希表，不可以有重复元素，元素是无序的，非同步的。

TreeSet：底层也是二叉树，存入它中的元素不可以重复并且是按自然排序的。

三、类的常见方法以及特有方法

常见方法：

增：

add();

删

remove()

改

set()

查

get()

Iterator();

LinkedList的特有方法：

ListIterator（）：因为iterator（）方法没有添加，修改等方法，LinkedList继承了Iterator有添加了自己独特的方法。

迭代器：ListIterator

ListIteratoriter= l.Listiterator();
while(iter.hasNext())
{
System.out.println(iter.next());
}

注意：在用迭代器遍历集合的时候，不能再通过集合操作元素，比如：向外取的同时进行添加，这样的话会出行并发修改异常。

四、集合中的常见操作

1）向集合中存入元素并且保证集合中的元素不能有重复

ArrayList对象：重写equals方法保证元素不能重复

如下代码：

/*
将自定义对象作为元素存到ArrayList集合中，并去除重复元素。
比如：存人对象。同姓名同年龄，视为同一个人。为重复元素。
List集合判断元素是否相同，依据是元素的equals方法。*/
class Person
{
    private String name;
    privateintage;
    publicintgetAge() {
        returnage;
    }
    publicvoidsetAge(int age) {
        this.age = age;
    }
    Person(Stringname,int age)
    {
        this.name=name;
        this.age=age;
    }
    public StringgetName() {
        returnname;
    }
    publicvoidsetName(Stringname) {
        this.name = name;
    }
    publicbooleanequals(Object obj)
    {
        if(!(objinstanceof Person) )
        returnfalse;
           Person p=(Person)obj;
        returnthis.name.equals(p.name)&&this.age==p.age;
       
    }
}
publicclassArrayListDemo2 {
    publicstaticvoidmain(String[] args) {
        ArrayList<Person>al=newArrayList<Person>();
        al.add(new Person("lisi",10));
        al.add(new Person("zhangsan",20));
        al.add(new Person("wangwu",30));
        al.add(new Person("zhaoliu",40));
        al.add(new Person("zhaoliu",40));
        ArrayList<Person>newal=SingleElement(al);
        for(Personp:newal)
        {
            System.out.println(p.getName()+":::"+p.getAge());
        }
    }
    publicstaticArrayList<Person>SingleElement(ArrayList<Person>al)
    {
        ArrayList<Person>newal=newArrayList<Person>();
        Iterator<Person>it = al.iterator();
        while(it.hasNext())
        {
            Personp=it.next();
            if(!newal.contains(p))
            newal.add(p);
        }
        returnnewal;
    }
}

hashSet集合保证元素唯一性是：元素对象重写HashCode方法，然后再重写equals方法。

如下代码：

/*
往hashSet集合中存入自定对象
姓名和年龄相同为同一个人，重复元素。
*/
classPerson
{
private String name;
privateintage;
publicPerson1(String name, int age) {
        super();
        this.name = name;
        this.age = age;
    }
publicinthashCode()
    {
        returnname.hashCode()+age*12;
   
    }
publicbooleanequals(Object obj)
    {
    if(!(objinstanceofPerson1))
        returnfalse;
    Person1 p=(Person1)obj;
    returnthis.name.equals(p.name)&&this.age==p.age;
   
    }
    public StringgetName() {
        returnname;
    }
    publicvoidsetName(Stringname) {
        this.name = name;
    }
    publicintgetAge() {
        returnage;
    }
    publicvoidsetAge(int  age) {
        this.age = age;
    }
   
}
publicclassHashSetTest{
 
    publicstaticvoidmain(String[] args) {
        HashSet<Person1>hs=newHashSet<Person1>();
        hs.add(newPerson1("lisi01",30));
        hs.add(newPerson1("lisi02",40));
        hs.add(newPerson1("lisi03",50));
        hs.add(newPerson1("lisi03",50));
        hs.add(newPerson1("lisi04",60));
           Iterator<Person1> it = hs.iterator();
while(it.hasNext())
                {
    Person1 p=it.next();
    System.out.println(p.getName()+"::"+p.getAge());
                }
    }
}

TreeSet集合

往集合中存入元素并且可以按指定的元素进行排序

实例如下：

/*需求：
往TreeSet集合中存储自定义对象学生。
想按照学生的年龄进行排序。
*/
class Student implementsComparable
{
private String name;
privateintage;
publicStudent(String name, int age) {
  super();
  this.name = name;
  this.age = age;
}
public StringgetName() {
  returnname;
}
publicvoidsetName(Stringname) {
  this.name = name;
}
publicintgetAge() {
  returnage;
}
publicvoidsetAge(int age) {
  this.age = age;
}
@Override
publicintcompareTo(Objecto) {
  // TODOAuto-generated method stub
  if(!(o instanceof Student))
      thrownewRuntimeException("不是学生对象");
   Students=(Student)o;
  if(this.age>s.age)
      return 1;
  elseif(this.age==s.age)
   {
      returnthis.name.compareTo(s.name);
   }
  return -1 ;
}
}
publicclassTreeSetTest1 {
  /**
   * @paramargs
   */
  publicstaticvoidmain(String[] args) {
      // TODOAuto-generated method stub
TreeSet<Student>tr=newTreeSet<Student>(newMyComper());
tr.add(new Student("lisi04",23));
tr.add(new Student("lisi02",21));
tr.add(new Student("lisi03",22));
tr.add(new Student("lisi03",29));
tr.add(new Student("lisi01",20));
         Iterator<Student> it =tr.iterator();
while(it.hasNext())
           {
    Student s=it.next();
  System.out.println(s.getName()+":::"+s.getAge());
           }
  }
}
classMyComperimplementsComparator
{
  @Override
  publicintcompare(Object o1, Object o2) {
      // TODOAuto-generated method stuben
       Student s1=(Student)o1;
       Student s2=(Student)o2;
      int sum=s1.getName().compareTo(s2.getName());
      if(sum==0)
          returnnewInteger(s1.getAge()).compareTo(newInteger(s2.getAge()));
      return sum;
  }
}

Map集合与Collection在集合框架中是并列存在的。

Map集合：该集合存储键值对。一对一对往里存。而且要保证键的唯一性。

1，添加。

put(Kkey, V value)

putAll(Map<?extends K,? extends V> m)

2，删除。

clear()

remove(Objectkey)

3，判断。

containsValue(Objectvalue)

containsKey(Objectkey)

isEmpty()

4，获取。

get(Objectkey)

size()

values()

entrySet()

keySet()

Map

Hashtable:底层是哈希表数据结构，不可以存入null键null值。该集合是线程同步的。

其中的键值必须实现equals和hashcode方法

HashMap：底层是哈希表数据结构，允许使用 null 值和 null 键，该集合是不同步的。将hashtable替代。

TreeMap：底层是二叉树数据结构。线程不同步。可以用于给map集合中的键进行排序。

Map集合的两种取出方式：

方式一：Set<k>keySet：将map中所有的键存入到Set集合。因为set具备迭代器。

所有可以迭代方式取出所有的键，在根据get方法。获取每一个键对应的值。

Map集合的取出原理：将map集合转成set集合。在通过迭代器取出。

代码如下：

Set<String> set = hm.keySet();
        Iterator<String>it = set.iterator();
        while(it.hasNext())
        {
            Strings=it.next();
            System.out.println(s+"::"+hm.get(s));
       
        }

方式二：Set<Map.Entry<k,v>>entrySet：将map集合中的映射关系存入到了set集合中，

而这个关系的数据类型就是：Map.EntryEntry，

其实就是Map中的一个static内部接口。

为什么要定义在内部呢？

因为只有有了Map集合，有了键值对，才会有键值的映射关系。

关系属于Map集合中的一个内部事物。

而且该事物在直接访问Map集合中的元素。

代码如下：

Set<Map.Entry<String,String>> set=hm.entrySet();
        Iterator<Map.Entry<String, String>>it= set.iterator();
        while(it.hasNext())
        {
            Map.Entry<String,String>me=it.next();
            System.out.println(me.getValue()+ ":::" +me.getKey());
        }

三、集合框架的一些工具类：

Collections类--à里面都是静态方法

专门用于对集合操作的，可以对List集合进行排序

Sort();对List集合进行排序

不能给set集合排序

max();获取对象最大值

public static <T>intbinarySearch(List<? extendsComparable<? super T>> list, Tkey)折半查找

file()将集合中的所用元素替换成指定的元素

replaceAll();将指定的元素替换成其他元素

reverseOrder();逆向比较器

Collections可以把一个不安全的集合转化成安全的

Swap()

Shuffle();对集合中的元素进行任意位置置换，例如：扑克牌

Arrays-à用于操作数组的工具类。

toString();把数组变成字符串

asList();将数组变成List集合，注意：变成集合后不能对集合进行增删。因为数组的长度是固定的。

如果数组中的元素都是基本类型的转变成List集合时，他会把整个数组做为集合中的元素存在

集合变数组

集合中有个方法把集合转换成数组toArray（）

指定类型的数组到底要定义多长呢？

当指定类型的数组小于了集合的Size，该数组的内部会创建一个集合大小的数组，当指定类型的数组的长度大于了集合的长度，就不会再创建了

变数组的原因是：为了限定对元素的限定

增强for循环：继承Iterate接口可以用增强for循环

对集合进行取出，但不能对集合进行操作

可变参数：实际上里面封装的是数组，注意：可变参数必须放在参数列表的最后一个位置。

静态导入：importstatic

当类名重名是要指定类，当方法重名是要指定哪个类的方法

总结：保证存入ArrayList集合中的元素的唯一性，我们可以在一定一个新的ArrayList容器，把原有容器中的数据进行迭代，先将第一个存入到新的集合中，当下一个在存时，与第一进行比较，这要在person类中重写equals方法。因为Object中也有一个equals方法比较的是哈希值，这样的话每个类的哈希值是不一样的，所以要从写equals方法。

HashSet和HashMap保证元素唯一性的方法相同，将存入对象重写HashCode方法，然后再重写equals方法。

原因是：HashSet底层的数据结构的存储方式是哈希表，所以当判断有相同的哈希值时，所存入的对象有可能相同有可能不同，然后再用equals方法来判断一下对象是否相同即可保证元素是不相同的。

TreeSet和TreeMap保证元素唯一性的方法相同

第一种方式：当一个对象不具有比较性时，可以实现comparble接口并且重写compareTo方法来按照自己想要的比较方式

第二种方式：可以构造一个比较器，来实现compartor接口，并且重写compare方法。把比较器传给要进行比较的集合即可。

注意：当比较元素时，主要条件相同时比较次要条件。

当TreeSet和TreeMap的两种方式都存在时，按照第二种方式。

------- 物联云培训、java培训、期待与您交流！ ----------