ArrayList怎么获取添加元素的索引 arraylist获取元素位置

Collection集合

——Collection集合集合概述和使用——

import java.util.ArrayList;
import java.util.Collection;
 //创建Collection集合的对象
public class CollectionDemo { 
public static void main(String[] args) {
 //创建Collection集合的对象
 Collection<String> c = new ArrayList<String>();
 //添加元素boolen add (E e)
 c.add("hello");
 c.add("world");
 c.add("java");
 //输出结合对象
out.println(c);
 }
 }
 ——Collection集合常用方法——
import java.util.ArrayList;
import java.util.Collection;
public class CollectionDemo { 
public static void main(String[] args) {
 //创建Collection集合的对象
new
 // System.out.println(c.add("hello"));
 c.add("hello");
 c.add("world");
 c.add("java");
 //c.clear();
 //System.out.println(c.remove("world"));
out.println(c);
 }
}
 ——Collection集合的遍历——
public class CollectionDemo { 
public static void main(String[] args) {
 //创建集合对象
 Collection<String> c = new ArrayList<String>();
 //在集合中添加元素
 c.add("hello");
 c.add("world");
 c.add("java");
 //interator<E>·interator():返回此集合中元素的迭代器，通过 集合的interator（）方法得到
 Iterator<String> it = c.iterator();
 //E next()返回迭代中的下一个元素
out.println(it.next());
out.println(it.next());
out.println(it.next());
 //·boolean hasNext():如果迭代具有更多元素，则返回ture
if(it.hasNext()) {
out.println(it.next());
 }
if(it.hasNext()) {
out.println(it.next());
 }
if(it.hasNext()) {
out.println(it.next());
 }
}
}
————————————— List集合——————————————— 
——List集合概述和特点——
import java.util.List;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
public class ListDemo {
public static void main(String[] args) {
 List<String> list = new ArrayList<String>();
 //在集合中添加元素
 list.add("hello");
 list.add("world");
 list.add("java");
//迭代器的方式遍历
 Iterator<String> it = list.iterator();
while (it.hasNext()) {
 String s = it.next();
out.println(s);
 }
 }
}
 ——List集合的特有方法——
import java.util.List;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
public class ListDemo {
 public static void main(String[] args) {
 List<String> list = new ArrayList<String>();
 //在集合中添加元素
 list.add("hello");
 list.add("world");
 list.add("java");
 //void add(int index , E element)在此集合中的指定位置插入指定的元素
//list.add(2,"javase");
 //E remowe(int index)删除指定索引处的元素，返回被删除的元素
//System.out.println(list.remove(1));
 //E set(int indexE element)修改指定索引处的元素，返回被修改的元素 
//System.out.println(list.remove(1));
 //E set(int index,E element)修改指定索引处的元素，返回被修改的元素
//System.out.println(list.set(1,"javase"));
 //E get(int index)返回指定索引处的元素
//System.out.println(list.get(2)); 
 //用for循环改进遍历
 for(int i=0; i<list.size(); i++){
 String s = list.get(i);
 System.out.println(list); 
 }
}
} 
 ——增强for循环——
public class ForDemo {
public static void main(String[] args) {
 //演示数组 for
 int[] arr = {1,2,3};
 for(int i : arr) {
 System.out.println(i);
 } 
 //演示字符串for 
 String[] strArray = {"hello","world"};
 for(String s : strArray ) {
 System.out.println(s);
 }
 //演示list的for
 List<String> list = new ArrayList<String>();
 list.add("hello");
 list.add("world");
 for(String s : ArrayList ) {
 System.out.println(s);
 } 
}
 ——list集合子类的特点——
import java.util.LinkedList;
public class ListDemo {
 public static void main(String[] args) {
 //创建集合对象
 ArrayList<String> array = new ArrayList<String>();
 array.add ("hello");
 array.add ("world");
 //遍历
 for(String s : array) {
 System.out.println(s);
 ——linkedlist集合的特有功能——
import java.util.LinkedList;
public class LinkedListDemo {
 public static void main(String[] args) {
 LinkedList<String> linkedList = new LinkedList<String>();
 linkedList.add ("hello");
 linkedList.add ("world");
 //public void addFirst(E e);在该列表开头插入指定元素
 // public void addLast(E e);在该列表开头插入指定元素
 // linkedList.addFirst("java");
 // linkedList.addLast("java");
 // public E getFirst();返回此列表中的第一个元素
 // System.out.println(linkedList.getFirst());
 // public E getLast();返回此列表中的最后一个元素
 // System.out.println(linkedList.getLast());
 // public removeFirst();从此列表中删除并返回第一个元素
 System.out.println(linkedList.removeFirst());
 // public removeLast();从此列表中删除并返回最后一个元素
//System.out.println(linkedList.removeLast());
 System.out.println(linkedList);
}
}
————————————set集合——————————————
 ——Set集合概述和特点——
 import java.util.Set;
 import java.util.HashSet;
public class SetDemo {
 public static void main(String[] args) {
 Set<String> set = new HashSet<String>();
 set.add ("hello");
 set.add ("world");
 //不包含重复元素的结合
 set.add ("java");
 //遍历
 for(String s : set) {
 System.out.println(s);
 }
 }
}
 ——哈希值——
public class Student {
 private String name;
 private int age;
 public Student() {
 }
 public 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 ;
 }
 }
public class HashDemo {
 public static void main(String[] args) {
 Student s1 = new Student("林青霞",30);
 //同一个对象多次调用hashCode()方法返回的哈希值是不相同的；
 System.out.println(s1.hashCode());
 System.out.println(s1.hashCode());
 //通过方法重写，可以实现不同对象的哈希值 是相同的
 System.out.println("hello".hashCode());
 System.out.println("world".hashCode())； 
 Student s2 = new Student("林青霞",30); 
 //默认情况下，不同对象的哈希值是不相同的
 System.out.println(s2.hashCode());
 }
 }
 ——哈希值集合概述和特点——
import java.util.HashSet;
public class HashSetDemo {
 public static void main(String[] args) {
 HashSet<String> hs = new HashSet<String>();
 hs.add("hello");
 hs.add("world");
 for(String s : hs) {
 System.out.println(s)；
 }
 }
}
 ——LinkedHashSet集合概述和特点——
import java.util.LinkedHashSet;
public class LinkedHashSetDemo {
 public static void main(String[] args) {
 LinkedHashSet<String> linkedHashSet = new LinkedHashSet<String>();
 linkedHashSet.add("hello");
 linkedHashSet.add("world");
 for(String s : linkedHashSet) {
 System.out.println(s);
 }
 }
 }
 ——TreeSet集合概述和特点——
import java.util.TreeSet;
public class TreeSetDemo {
 public static void main(String[] args) {
 TreeSet<Integer> treeSet = new TreeSet<Integer>();
 treeSet.add(10);
 treeSet.add(20);
 for(Integer i : treeSet) {
 System.out.println(i);
 }
 }
}
 ——自然排序Comparablie的使用——
public class Student implements Comparable<Student>{
 private String name;
 private int age;
 public Student() {
 }
 public 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(Student s) {
 //return 0;
 //return 1;
 //return -1;
 //按年龄从小到大的顺序
 int num = this.age - s.age;
 //年龄相同时，按照姓名的字母顺序排序；
 int num2 = num==0?this.name.compareTo(s.name):num;
 return num2;
 }
}
_____________
import java.util.TreeSet;
public class TreeSetDemo {
 public static void main(String[] args) {
 TreeSet<Student> ts = new TreeSet<Student>(); 
 Student s1 = new Student("lin",12);
 Student s2 = new Student("wang",15);
 Student s3 = new Student("chen",18);
 Student s4 = new Student("feng",18);
 ts.add(s1);
 ts.add(s2);
 ts.add(s3);
 ts.add(s4); 
 for(Student s : ts) {
 System.out.println(s.getName()+","+s.getAge());
 } 
 }
}
 ——比较器排序Comparator的使用——
import java.util.Comparator;
import java.util.TreeSet;
public class TreeSetDemo {
 public static void main(String[] args) {
 TreeSet<Student> ts = new TreeSet<Student>(new Comparator<Student>() {
 @Override
 public int compare(Student s1 , Student s2) {
 int num = s1.getAge() - s2.getAge();
 int num2 = num==0?s1.getName().compareTo(s2.getName()) : num ;
 return num2;
 }
 });
 Student s1 = new Student("lin",12);
 Student s2 = new Student("wang",15);
 Student s3 = new Student("chen",18);
 Student s4 = new Student("feng",18);
 ts.add(s1);
 ts.add(s2);
 ts.add(s3);
 ts.add(s4); 
 for(Student s : ts) {
 System.out.println(s.getName()+","+s.getAge());
 } 
}
}
—————————————泛型类————————————
 ——泛型概述和好处——
import java.util.Collection;
import java.util.Iterator;
import java.util.ArrayList;
public class GenericDemo {
 public static void main(String[] args) {
 Collection<String> c = new ArrayList<String>();
 c.add("hello");
 c.add("world");
 //遍历集合
 //Iterator it = c.iterator();
 Iterator<String> it = c.iterator();
 while(it.hasNext()) {
 //Iterator默认为object类型
 // Object obj = it.next();
//System.out.println(obj);
 //将Obeject转化为String类型
 //String s = (String)it.next();
 String s = it.next();
 System.out.println(s);
 }
 }
}
 ——泛型类——
Stuent

Generic

GenericDemo

——泛型方法——

public class GenericDemo {
 public static void main(String[] args) {
 Generic g = new Generic();
g.show("lin");
g.show(30);
g.show(true);
g.show(12.3);
 }
 }
public class Generic{
 public <T> void show(T t) {
 System.out.println(t);
 }
}
结果
lin
30
true
12.3
 ——泛型接口——
public interface Generic<T>{
 void show(T t);
｝
public class GenericImpl<T> implements Generic<T>{
 @Override
 public void show(T t) {
 System.out.println(t);
 }
 }
public class GenericDemo {
 public static void main(String[] args) {
 Generic<String> g1 = new GenericImpl<String>();
g1.show("lin");
 Generic<Integer> g2 = new GenericImpl<Integer>();
g2.show(30);
 }
 }
 ——类型通配符——
import java.util.List;
import java.util.ArrayList;
public class GenericDemo {
public static void main(String[] args) {
 //类型通配符,<?>
 List<?> list1 =new ArrayList<Object>();
 List list2 =new ArrayList<Number>();
 List<?> list3 =new ArrayList<Integer>();
 System.out.println("......");
 //类型通配符上限：<?extends 类型>
 List <? extends Number> List4=new ArrayList<Number>();
 List <? extends Number> List5=new ArrayList<Number>();
 List <? extends Number> List6=new ArrayList<Number>();
 //类型通配符下限，<?super类型>
 List <? super Number> List7=new ArrayList<Number>();
 List <? super Number> List8=new ArrayList<Number>();
 List <? super Number> List9=new ArrayList<Number>();
 }
 }
——————————————————————————————————————
Map集合
 ——Map集合概述和特点——
import java.util.Map;
import java.util.HashMap;
public class MapDemo {
 public static void main(String[] args) {
 Map<String,String> map = new HashMap<String,String>();
 //V put(K key,V value)将指定的值与 映射中的指定键格相关联
 map.put("xuehao 001", "lin");
 map.put("xuehao 002", "wang");
 map.put("xuehao 003", "chen");
 //输出集合对象
 System.out.println(map);
 ｝
} 
 ——Map集合的基本功能——
import java.util.Map;
import java.util.HashMap;
public class MapDemo {
 public static void main(String[] args) {
 Map<String,String> map = new HashMap<String,String>();
 //V remove（Object key)根据删除键 值对元素
 map.put("lin", "zhao");
 map.put("wang", "chen");
 //void clear();将移除所有的键值对元素
 // map.clear();
 //boolean containsKey(Object key),判断集合是否包含指定的键
//System.out.println(map.containsKey("zhao"));
 //boolean isEmpety(),判断集合是否为空
//System.out.println(map.isEmpty());
 //int size集合的长度，也就是 集合中键值对的个数
 // System.out.println(map.size());
 }
}
 ——Map集合的获取功能——
import java.util.Map;
import java.util.Set;
import java.util.Collection;
import java.util.HashMap;
public class MapDemo {
 public static void main(String[] args) {
 Map<String,String> map = new HashMap<String,String>();
 //添加元素
 map.put("lin", "zhao");
 map.put("wang", "chen");
 //V get(Object key)根据键获取值
 System.out.println(map.get("lin"));
 //Set<K> keySet()获取所有值得集合
 //Set<String> keySet = map.keySet();
 //for(String key : keySet) {
 // System.out.println(key);
 //collection<V> values()获取所有值得集合
 Collection<String> values = map.values();
 System.out.println(values);
 } 
 }
 ——Map集合的遍历（方式1）——
import java.util.Set;
import java.util.HashMap;
public class MapDemo {
 public static void main(String[] args) {
 Map<String,String> map = new HashMap<String,String>();
 //添加元素
 map.put("lin", "zhao");
 map.put("wang", "chen");
 //获取所有键的集合，用keySet()方法实现
 Set<String> keySet = map.keySet();
 //遍历的集合，获取到每一个键，用增强for实现
 for(String key : keySet) {
 String value = map.get(key);
 System.out.println(key + "," + value);
 }
 }
}  ——Map集合的遍历（方式2）——
import java.util.Set;
import java.util.HashMap;
public class MapDemo {
 public static void main(String[] args) {
 Map<String,String> map = new HashMap<String,String>();
 //添加元素
 map.put("lin", "zhao");
 map.put("wang", "chen");
 //获取所有键值对对象的集合
 Set<Map.Entry<String, String>> entrySet = map.entrySet();
 //遍历键值对对象的集合，得到每一个键值对对象
 for(Map.Entry<String,String> me : entrySet) {
 //根据键值对对象获取键和值
 String key = me.getKey();
 String value = me.getValue();
 System.out.println(key + "," + value);
 }
 }
 }
——————————————————————————————————————
 Collections
——Collections概述和使用——
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
public class CollectionsDemo {
 public static void main(String[] args) {
 //创建集合对象
 List<Integer> list = new ArrayList<Integer>();
 //添加元素
 list.add(30);
 list.add(40);
 //public static <T extends Comparable<? super T>> void sort (List<T> list)将指定 的列表按升序排序
 // Collections.sort(list);
 // public static void reverse (List<?> list)反转指定列表中元素的顺序
//Collections.reverse(list);
 // public static void shuffle (List<?> list)使用默认的随机 源随机排列指定的列表
 Collections.shuffle(list);
 System.out.println(list);
 }
}