java学习第11天

集合
     集合 --》java AIP 所提供的一系列类的实例 可以用于动态存放多个对象

     集合中泛型的使用
           在定义一个集合时就指定集合存储的对象的数据类型

泛型方法
         public static <T>void method(T t){}
         public static<T> T method(T t){return (T) Object}

泛型接口

        interface 0perator<T>{void add(T t);}

----------------------------------------------------------------

ArrayList

 

public class ArrayListDemo {
 public static void main(String[] args) {
  ArrayList list = new ArrayList();
  
  list.add(1);  //  基本类型的包装类  -- Integer
  list.add(true); 
  list.add("string");
  System.out.println(list); //[1, true, string]
  
  Object object = list.get(1);
  
  if(object instanceof Boolean){
   System.out.println("boolean 类型");
  }else if(object instanceof Integer){
   System.out.println("Integer 类型");
  }else if(object instanceof String){
   System.out.println("String 类型");
  }
  System.out.println(object);
  
  
  //泛型：规定你进行操作的是数据类型
  ArrayList<String> list2 = new ArrayList<String>();
  list2.add("abcdefg");
  //list2.add(11); 通过泛型限定类型，如果你放其他类型进集合，会报错
  String string = list2.get(0);
  System.out.println(string);
  ArrayList<Integer> list3 = new ArrayList<Integer>();
  list3.add(1);
  System.out.println(list3.get(0));
 }
}

-------------------------------------------------------------------------

 //泛型的标签
 //调用方法的时候，可以通过传入不同参数类型，进而根据类型执行结果
 //
 public static  <E> void method(E e){
  System.out.println(e.getClass().getName());
 }
 
 //这个叫泛型方法，可以具体规定，某一类对象进行操作此方法
 public static  <E extends Person> void method2(E e){
  System.out.println(e.getName());
 }

-------------------------------------------------------------------------

import java.util.ArrayList;
import java.util.Iterator;

public class ListMethod {
 public static void main(String[] args) {
  
  //list集合的常用方法 
  
  //elementData  底层实现的是用数组进行保存
  ArrayList<String> list = new ArrayList<String>();
  //list打印元素顺序跟添加顺一样
  /*boolean boo = */
  list.add("0");  //list添加元素是否成功
  list.add("0");
  list.add("0");
  list.add("0");
  list.add("0");
  list.add("0");
  list.add("0");
  list.add("0");
  System.out.println(list); 
  System.out.println("size():" + list.size());
  
  //搜索
  //contains(Object o)   //判断元素是否存在
  if(list.contains("0")){
   System.out.println("存在");
  }
  //contains 使用equals 进行内存地址比较，如果自定义类需要根据属性进行判断是否
  //相等时，此时必须相应的重写Object equals方法
  /*ArrayList<Point> points = new ArrayList<Point>();
  Point point1 = new Point(1, 1);
  Point point2 = new Point(1, 1);
  points.add(new Point(1, 1));
  points.add(point2);
  
  if(points.contains(point1)){
   System.out.println("存在");
  }else{
   System.out.println("不存在");
  }*/
  
  //get(int index)  获取 。index
  System.out.println(list.get(3));
  //indexOf(Object o)
  //返回的是元素在list里面的下标，如果元素不存在，返回-1
  System.out.println(list.indexOf("a啊啊"));
  //isEmpty()    list.clear();
  // list.clear();  清空list集合
  if(list.isEmpty()){
   System.out.println("是空的");
  }else{
   System.out.println("不是空的");
  }
  
  //查找list的最后一个元素下标
  System.out.println(list.lastIndexOf("0"));
  
  
  //遍历
  //第一种：普通for循环
  for(int i = 0; i < list.size(); i++){
   System.out.print(list.get(i) + "  ");
  }
  System.out.println();
  //第二种：增强的for循环
  for(String str : list){
   System.out.print(str + " ");
  }
  System.out.println();
  //第三种：迭代循环
  //获取迭代器
  Iterator<String> iterator = list.iterator();
  for(;iterator.hasNext();  ){
   System.out.print(iterator.next() + " ");
  }
  //iterator 循环一次之后，如果你在进行调用的时候，一定注意他的位置
  //iterator 没有提供复位方法，那么只能重新new 另外一个迭代器
  //用法注意点：使用迭代器，一样要小心next 的使用，如果循环中没有next
  //让迭代器进行迭代，那么很有可能陷入死循环
  iterator = list.iterator();
  /*while (iterator.hasNext()) {
   System.out.println("进来了....");
  }*/
  
  
  //三种循环使用条件
  ArrayList<String> list2 = new ArrayList<String>();
  list2.add("0");
  list2.add("1");
  list2.add("2");
  list2.add("3");
  list2.add("4");
  list2.add("5");
  list2.add("6");
  list2.add("7");
  System.out.println();
  
  
  //如果list需要循环添加后删除时，不要使用for循环
  //因为容易造成下标混乱
  /*System.out.println("删除前：" + list2);
  for(int i = 0; i < list2.size(); i++){
   list2.remove(i);
  }
  System.out.println("删除后：" + list2);*/
  
  //java.util.ConcurrentModificationException
  //增强for循环，只能用于循环遍历，无法进行修改(添加 删除)
  //因为语法要求，for循环中的集合或数组能动态改变
  /*for(String str : list2){
   list2.add("11222");
  }*/
  
  
  //迭代器进行迭代是通过iterator2.next()进行的，如果next超过元素的个会报错
  //java.util.NoSuchElementException
  System.out.println("删除前：" + list2);
  Iterator<String> iterator2 = list2.iterator();
  /*for(;iterator2.hasNext();){
   String a = iterator2.next();
   if("1".equals(a)){
    iterator2.remove();
   }
  }*/
  
  /*for(;iterator2.hasNext();){
   iterator2.next();
   iterator2.next();
   if("1".equals(iterator2.next())){
    iterator2.remove();
   }
  }*/
  /*int i = 0;
  for(;iterator2.hasNext();){
   
   if("1".equals(iterator2.next())){
    System.out.println("-----");
    iterator2.remove();
   }
   i++;
  }
  System.out.println(i);
  */
  
  for(;iterator2.hasNext();){
   if("1".equals(iterator2.next())){
    // java.util.ConcurrentModificationException
    //只能同过迭代进行操作list2集合
    /*list2.add("11");
    list2.add("111");*/
   }
  }
  
  System.out.println("删除后：" + list2);
  /**
   * 总结：什么使用for    增强 for   迭代
   * 1、程序关注下吧时候使用for
   * 2、程序关注元素内容(元素加工,非添加或删除，而是修改元素的属性)
                 * 使用增强for
   * 3、如果元素进行的修改(指删除，迭代器的删除)，使用迭代器
   */
 }
}

------------------------------------------------------------------------

三种循环遍历

public class Test {
 public static void main(String[] args) {
  ArrayList<Student> list = new ArrayList<Student>();
  for(int i = 0; i < 10; i++){
   list.add(new Student("name_" + i , "password_" + i));
  }
  
  System.out.println(list);
  
  for(int i = 0; i < list.size(); i++){
   System.out.println(list.get(i).toString());
  }
  
  System.out.println("增强型for循环--------------------");
  for(Student student : list){
   student.setName("aaaaa");
   System.out.println(student);
  }
  
  System.out.println("迭代循环--------------------");
  Student stud =null;
  for(Iterator<Student> iterator = list.iterator(); iterator.hasNext();){
   stud = iterator.next();
   System.out.println(stud);
  }
 }
}

------------------------------------------------------------------------------

链表
 
public class Node {
 public Node next;  //向后
 public String data;
 public Node priv;  //向前
 public static void main(String[] args) {
  /*//单项链表  start
  Node node1 = new Node();
  Node node2 = new Node();
  Node node3 = new Node();
  
  //1 --> 2
  node1.next = node2;
  node2.next = node3;
  node3.next = null;
  
  //单项链表  end
  */  
  
  //双向链表
  Node node1 = new Node();
  Node node2 = new Node();
  Node node3 = new Node();
  
  //1--->2 ---> 3
  node1.next = node2;
  node2.next = node3;
  node3.next = null;
  
  // 3 ---> 2 ---> 1
  node3.priv = node2;
  node2.priv = node1;
  node1.priv = null;
  
 }
}
-------------------------------------------------------------------------------

链表集合

import java.util.LinkedList;
import java.util.ListIterator;

public class LinkedDemo {
 public static void main(String[] args) {
  
  LinkedList<String> list = new LinkedList<String>(); //链表
  list.add("0");
  list.add("1");
  list.add("2");
  list.add("3");
  list.add("4");
  list.add("5");
  list.add("6");
  list.add("7");
  
  ListIterator<String> listIterator = (ListIterator<String>) list.iterator();
  /*for(; listIterator.hasNext();){
   System.out.println(listIterator.next());
  }
  System.out.println("----------------------------");
  for(; listIterator.hasPrevious();){
   System.out.println(listIterator.previous());
  }*///previous 像后移 和next 向前相反
  
  for(; listIterator.hasNext();){//判断右边还有没有值
   //listIterator.add("8");
   //list.add("888");
   listIterator.next(); //向右边迭代 移动
   listIterator.set("88");  //将当前对应下标对应的值设置88
   System.out.println(listIterator.nextIndex());  //下一个下标示多少
   System.out.println(list);
  }
  String str = null;
  for(;listIterator.hasPrevious();){//判断左边还有没有值
   str = listIterator.previous();//向左边 迭代 移动
   System.out.println(str);
  }
  //System.out.println(list);
 }
}