java 集合循环取最大值 java集合最大长度

一、集合：就像是一种容器，用于存储、获取和操作对象的容器

1. 数组的弊端

①数组的长度是不可变的 ②没有提供可以查看有效元素个数的方法

2. 集合的特点

①集合的长度是可变的

②集合可以存储任意类型的对象

③集合只能存储对象

3. 集合框架：

java.util.Collection : 集合层级的根接口

|--java.util.List : 有序的，并且允许重复（List 体系集合都有索引值）

|--ArrayList ：采用数组结构存储元素。查询操作多时，选择。

|--LinkedList ：采用链表结构存储元素。增删操作多时，选择。

|--Vector ：

|--java.util.Set : 无序的，并且不允许重复的

|--HashSet ：是 Set 接口的典型实现类

HashSet 判断元素是否存在的依据：采用哈希算法。先比较 hashCode 值，若 hashCode 值不存在

直接存储，若 hashCode 值存在，则再通过 equals() 比较两个对象的内容

注意：重写 hashCode() 方法与 equals() 方法二者保持一致！

|--LinkedHashSet ：相较于 HashSet 多了链表维护元素的顺序。增删效率低于 HashSet

遍历效率高于 HashSet (视情况而定)

|--TreeSet ：拥有指定的排序方式

①自然排序(Comparable):

1)需要添加到 TreeSet 集合中对象的类实现 Comparable 接口

2)重写 compareTo(Object o1) 方法

②定制排序(Comparator)-比较器:

1)声明一个类实现 Comparator 接口

2)重写 compare(Object o1, Object o2) 方法

3)将该实现类的实例作为参数传递给 TreeSet 的构造器

二、集合的遍历：

List list = new ArrayList(); 

 
 

 

  list.add("AA"); 

 

  list.add("BB"); 

 

  list.add("CC"); 

 

  list.add("DD"); 

 

  list.add("EE");

1. 增强 for 循环

for(被遍历集合中元素的数据类型 变量名 : 被遍历的集合){ 

 
 
 
 

  }

例如：

for(Object obj : list){ 

 

  System.out.println(obj); 

 

  }

2. 使用 Iterator 迭代器

//①获取当前集合的迭代器 

 

  Iterator it = list.iterator(); 

 
 

 

  //②通过 hasNext() 与 next() 方法遍历集合元素 

 

  while(it.hasNext()){ 

 

  Object obj = it.next(); //注意：通常一个 hasNext() 方法配合一个 next() 使用 

 

  System.out.println(obj); 

 

  }

3. (了解)列表迭代器： ListIterator (是 List 集合特有的迭代器)

@Test 

 

  public void test2(){ 

 

  List list = new ArrayList(); 

 
 

 

  list.add("AA"); 

 

  list.add("BB"); 

 

  list.add("CC"); 

 

  list.add("DD"); 

 

  list.add("EE"); 

 
 

 

  //需求：判断若集合中元素为 "BB" ， 在该元素位置添加一个 "bbb" 

 

  ListIterator li = list.listIterator(); 

 
 

 

  while(li.hasNext()){ 

 

  Object obj = li.next(); 

 
 

 

  if(obj.equals("BB")){ 

 

  li.add("bbb"); 

 

  } 

 

  } 

 
 

 

  for (Object o : list) { 

 

  System.out.println(o); 

 

  } 

 
 }

一、java.util.Map : 用于操作成对对象的集合。具有 key(键)-value(值)对映射关系的集合

一个 key 对应着一个 value, key 不允许重复

|--HashMap : 是 Map 接口的典型实现类。是线程不安全的，因此效率高。允许 null 作为 key 和 value

|--LinkedHashMap :

|--Hashtable : 是线程安全的，因此效率低。

|--Properties : 用于操作属性文件

|--TreeMap : 根据 key 拥有指定的排序方式

①自然排序(Comparable)：

②定制排序(Comparator)：

//利用 Properties 操作属性文件 

 

  @Test 

 

  public void test3() throws IOException{ 

 

  //1. 创建 Properties 的实例 

 

  Properties props = new Properties(); 

 

  Properties props = new Properties(); 

 

  //2. 通过 load(InputStream in) 方法加载属性文件 

 

  props.load(new FileInputStream("jdbc.properties")); 

 

  props.load(new FileInpurStream("jdbc.properties")); 

 

  //3. 通过 getProperty(String key) 获取对应的 value(注意：key 和 value 都是 String) 

 

  String userName = props.getProperty("username");String uesrName = props.getProperties("username"); 

 

  String password = props.getProperty("password");String password = props.getProperties("password"); 

 
 

 

  System.out.println(userName); 

 

  System.out.println(password); 

 
 

 

  }

二、Map 的常用方法：

添加、删除操作：

Object put(Object key,Object value) 

 

  Object remove(Object key) 

 

  void putAll(Map t) 

 

  void clear()

元素查询的操作：

Object get(Object key) 

 

  boolean containsKey(Object key) 

 

  boolean containsValue(Object value) 

 

  int size() 

 

  boolean isEmpty() 

 

  boolean equals(Object obj)

元视图操作的方法：

Set keySet() 

 

  Collection values() 

 

  Set entrySet()

三、Map 的遍历

@Test 

 

  public void test4(){ 

 

  Map<String, Integer> map = new HashMap<>(); 

 
 

 

  map.put("AA", 11); 

 

  map.put("BB", 22); 

 

  map.put("CC", 33); 

 

  map.put("DD", 44); 

 

  map.put("EE", 55); 

 
 

 

  //遍历 Map 的方式一：获取 Map 中所的 key 组成的 Set 

 

  Set<String> set = map.keySet(); 

 
 

 

  for (String str : set) { 

 

  System.out.println(str.toLowerCase()); 

 

  System.out.println(map.get(str)); 

 

  } 

 
 

 

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

 
 

 

  //遍历 Map 的方式二：获取 Map 中所的 value 组成的 Collection 

 

  Collection<Integer> coll = map.values(); 

 
 

 

  Iterator<Integer> it = coll.iterator(); 

 
 

 

  while(it.hasNext()){ 

 

  Integer num = it.next(); 

 

  System.out.println(num); 

 

  } 

 
 

 

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

 
 

 

  //遍历 Map 的方式三：获取 Map 中所的 Entry(是 Map 的内部类，一个 Entry 对应着一个 key 和一个 value) 组成的 Set 

 

  Set<Entry<String, Integer>> entrySet = map.entrySet(); 

 
 

 

  for (Entry<String, Integer> entry : entrySet) { 

 

  String key = entry.getKey(); 

 

  Integer value = entry.getValue(); 

 

  System.out.println(key + "=" + value); 

 

  } 

 
 

 

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

 
 

 

  Iterator<Entry<String, Integer>> it2 = entrySet.iterator(); 

 
 

 

  while(it2.hasNext()){ 

 

  Entry<String, Integer> entry = it2.next(); 

 

  String key = entry.getKey(); 

 

  Integer value = entry.getValue(); 

 
 

 

  System.out.println(key + "=" + value); 

 

  } 

 

  }

一、Collections ： 用于操作集合的工具类

排序操作：（均为static方法

reverse(List)：反转 List 中元素的顺序

shuffle(List)：对 List 集合元素进行随机排序

sort(List)：根据元素的自然顺序对指定 List 集合元素升序排序

sort(List，Comparator)：根据指定的 Comparator 产生的顺序对 List 集合元素进行排序

swap(List，int， int)：将指定 list 集合中的 i 处元素和 j 处元素进行交换

查找、替换

Object max(Collection)：根据元素的自然顺序，返回给定集合中的最大元素

Object max(Collection，Comparator)：根据 Comparator 指定的顺序，返回给定集合中的最大元素

Object min(Collection)

Object min(Collection，Comparator)

int frequency(Collection，Object)：返回指定集合中指定元素的出现次数

void copy(List dest,List src)：将src中的内容复制到dest中

boolean replaceAll(List list，Object oldVal，Object newVal)：使用新值替换 List 对象的所旧值

一、为什么使用泛型：若集合中不使用泛型，意味着集合中可以存储任意类型的对象，若需要具体到某一个数据类型时

需要强制类型转换，可能引发 ClassCastException

二、泛型：是 jdk 1.5 后， 泛型在 Java 中以 "<>" 的形式呈现，

"<>" 中写引用数据类型，用于限制集合中存放元素的类型 

 
 
 
 

  1. 集合中使用泛型 

 
 
 
 

  //集合中使用泛型 

 

  @Test 

 

  public void test6(){ 

 

  List<String> list = new ArrayList<>(); 

 
 

 

  list.add("AA"); 

 

  list.add("BB"); 

 
 
 
 

  for (String str : list) { 

 

  System.out.println(str.toLowerCase()); 

 

  } 

 

  } 

 
 

 

  //不使用泛型的弊端 

 

  @Test 

 

  public void test5(){ 

 

  List list = new ArrayList(); 

 
 

 

  list.add("AA"); 

 

  list.add("BB"); 

 

  list.add(123); 

 
 

 

  for (Object o : list) { 

 

  String str = (String) o; 

 

  System.out.println(str.toLowerCase()); 

 

  } 

 
 

 

  }

2. 自定义泛型类、接口、方法

public class DAO<T>{ //T : Type E:Element K : Key V: Value 

 

  private List<T> list = new ArrayList<T>(); 

 
 
 
 

  public void add(T t){ 

 

  list.add(t); 

 

  } 

 
 
 
 

  public T get(int id){ 

 

  return list.get(id); 

 

  } 

 
 
 
 

  //自定义泛型方法 

 

  public static <E> E sort(E e){ 

 
 

 

  } 

 

  } 

 
 
 
 

  DAO<User> dao = new DAO<User>(); 

 

  dao.add(new User()); 

 
 
 
 

  class UserDAO extends DAO<User>{ 

 
 
 
 

  }

3. 通配符 ( ? ) ： 虽然 Person 是 Student 的父类。 但是 List<Person> 就不是 List<Student> 的父类。

就意味着不能使用多态，就意味着会大大降低程序的灵活性。

List<?> : 可以接收任意泛型类型的集合 

 

  List<? extends Person> : 可以接收 Person 本类泛型类型的集合及 Person 子类泛型类型的集合 

 

  List<? super Person> : 可以接收 Person 本类泛型类型的集合及 Person 父类泛型类型的集合 

 
 
 
 

  Student stu = new Student(); 

 

  Person p = stu; 

 
 
 
 

  Student[] stus = new Student[3]; 

 

  Person[] persons = stus; 

 
 
 
 

  List<Student> stuList = new ArrayListL<Student>(); 

 

  List<Person> perList = stuList; //不支持这种写法

例如：

List<?> list = stuList; //可以 

 
 
 
 
 

 

  /* 

 

  //需求：展示一堆学生吃饭走路的功能 

 

  public static void show(List<Student> list){ 

 

  for(Student stu : list){ 

 

  stu.eat(); 

 

  stu.walk(); 

 

  } 

 

  } 

 
 
 
 

  //需求：展示一堆男人吃饭走路的功能 

 

  public static void show(List<Man> list){ 

 

  for(Man man : List){ 

 

  man.eat(); 

 

  man.walk(); 

 

  } 

 

  } 

 

  */ 

 
 
 
 
 
 
 

  pubic static void show(List<? extends Person> list){ 

 

  for(Person p : list){ //多态 

 

  p.eat(); //虚拟方法调用 

 

  p.walk(); 

 

  } 

 

  }