集合/泛型/集合工具类/迭代器/比较器

集合

  • list存储的数据是不唯一，有序的对象。
  • set存储的数据是唯一，无序的对象。

List常用方法

  1. void add(int index, E element)在指定位置插入元素，后面的元素都往后移一个元素。
  2. boolean addAll(int index, Collection<? extends E> c)在指定的位置中插入c集合全部的元素，如果集合发生改变，则返回true，否则返回false。
  3. E get(int index)返回list集合中指定索引位置的元素
  4. int indexOf(Object o)返回list集合中第一次出现o对象的索引位置，如果list集合中没有o对象，那么就返回-1
  5. ListIterator<E> listIterator()返回此列表元素的列表迭代器（按适当顺序）。
  6. ListIterator<E> listIterator(int index)从指定位置开始，返回此列表元素的列表迭代器（按适当顺序）。和上面那个迭代器不同的就是多了一个参数，能控制迭代器开始的位置。
  7. E remove(int index)删除指定索引的对象
  8. E set(int index, E element)在索引为index位置的元素更改为element元素
  9. List<E> subList(int fromIndex, int toIndex)返回从索引fromIndex到toIndex的元素集合，包左不包右
  10. E clear()清除所有元素
  11. E containsAll()判断指定集合是否包含另一个集合的所有元素
  12. E isEmpty()是否为空

Map常用方法

  1. V put(K key, V value)向map集合中添加Key为key，Value为value的元素，当添加成功时返回null，否则返回value。
  2. void putAll(Map<? extends K,? extends V> m)向map集合中添加指定集合的所有元素
  3. void clear()把map集合中所有的键值删除
  4. boolean containsKey(Object key)检出map集合中有没有包含Key为key的元素，如果有则返回true，否则返回false。
  5. boolean containsValue(Object value)检出map集合中有没有包含Value为value的元素，如果有则返回true，否则返回false。
  6. Set<Map.Entry<K,V>> entrySet()返回map到一个Set集合中，以map集合中的Key=Value的形式返回到set中。
  7. boolean equals(Object o)判断两个Set集合的元素是否相同
  8. V get(Object key)根据map集合中元素的Key来获取相应元素的Value
  9. int hashCode()返回map集合的哈希码值
  10. boolean isEmpty()检出map集合中是否有元素，如果没有则返回true，如果有元素则返回false
  11. Set<K> keySet()返回map集合中所有Key
  12. V remove(Object key)删除Key为key值的元素
  13. int size()返回map集合中元素个数
  14. Collection<V> values()返回map集合中所有的Value到一个Collection集合

泛型

作用：

  1. 数据安全
  2. 防止类型转换时出错

包装类

ArrayList<Integer> arr = new ArrayList();

泛型类

public class Box<T> {
   
  private T t;
 
  public void add(T t) {
    this.t = t;
  }
 
  public T get() {
    return t;
  }
 
  public static void main(String[] args) {
    Box<Integer> integerBox = new Box<Integer>();
    Box<String> stringBox = new Box<String>();
 
    integerBox.add(new Integer(10));
    stringBox.add(new String("菜鸟教程"));
 
    System.out.printf("整型值为 :%d\n\n", integerBox.get());
    System.out.printf("字符串为 :%s\n", stringBox.get());
  }
}

泛型方法

public class GenericMethodTest
{
   // 泛型方法 printArray                       
   public static < E > void printArray( E[] inputArray )
   {
      // 输出数组元素          
         for ( E element : inputArray ){      
            System.out.printf( "%s ", element );
         }
         System.out.println();
    }
 
    public static void main( String args[] )
    {
        // 创建不同类型数组： Integer, Double 和 Character
        Integer[] intArray = { 1, 2, 3, 4, 5 };
        Double[] doubleArray = { 1.1, 2.2, 3.3, 4.4 };
        Character[] charArray = { 'H', 'E', 'L', 'L', 'O' };
 
        System.out.println( "整型数组元素为:" );
        printArray( intArray  ); // 传递一个整型数组
 
        System.out.println( "\n双精度型数组元素为:" );
        printArray( doubleArray ); // 传递一个双精度型数组
 
        System.out.println( "\n字符型数组元素为:" );
        printArray( charArray ); // 传递一个字符型数组
    } 
}

集合工具类

有很多，以下为截取。

        System.out.println(Collections.max(list));
        System.out.println(Collections.min(list));
        Collections.binarySearch(list, "i")   
        //混洗，洗牌：打乱已有顺序
        Collections.shuffle(list);
        Collections.reverse(list);
        Collections.swap(list , 2, 3);   
        Collections.replaceAll(list, "a", "A");     
        Collections.fill(list, "H");

        Arrays.binarySearch(arr, 2);
        Arrays.sort(arr);

迭代器

遍历：

    //使用迭代器遍历ArrayList集合
    Iterator<String> listIt = list.iterator();
    while(listIt.hasNext()){
        System.out.println(listIt.next());
    }
    //使用迭代器遍历Set集合
    Iterator<String> setIt = set.iterator();
    while(setIt.hasNext()){
        System.out.println(listIt.next());
    }
    //使用迭代器遍历LinkedList集合
    Iterator<String> linkIt = linkList.iterator();
    while(linkIt.hasNext()){
        System.out.println(listIt.next());
    }

比较器

自定义比较器：Comparable，Comparator

  1. Comparable: 内部比较器（侵入性，需要修改原有代码）

    • 思路：将比较的对象实现Comparable接口，重写类的compareTo()方法。在compareTo()中编写比较的逻辑。重点是返回值。

    • 返回值：

      • 1： 正数：当前对象大，降序。
      • -1：负数：传入的对象大，升序
      • 0： 一样大
    • 使用：Collections.sort();

  2. Comparator：外部比较器（无侵入性，不影响原有代码）

    • 定义：定义外部比较类 implements Comparator实现比较逻辑。
    • 使用：Collections.sort(students, new MyComparatorWithId());

参考链接：

版权属于：moluuser

本文链接：https://archive.moluuser.com/archives/26/

知识共享许可协议
本作品采用知识共享署名-非商业性使用-相同方式共享 4.0 国际许可协议进行许可。


正文到此结束


扫一扫在手机打开当前页
© 允许规范转载

【我要纠错】