2019-05-26 Java学习日记 day16

集合框架

List

ArrayList去重复方法

public class demo1_ArrayList {

    public static void main(String[] args) {
        //创建新集合将重复元素去掉
        ArrayList list =new ArrayList();
        list.add("a");
        list.add("a");
        list.add("c");
        list.add("c");
        list.add("a");
        
        ArrayList newlist=getSing(list);
        System.out.println(newlist);

    }
    public static ArrayList getSing(ArrayList list){
        ArrayList newlist = new ArrayList<>();//创建新集合
        Iterator it = list.iterator();    //根据传入的集合(老集合)获取迭代器
        while (it.hasNext()) {       //遍历老集合
            Object obj1= it.next();  //记录每一个元素
            if (!newlist.contains(obj1)) { //如果新集合不包含老集合中的元素
                newlist.add(obj1);  //将该元素添加
            } 
        }
        return newlist;
    }
}

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


        /* 重写equals()方法
         * contains和remove判断都是依赖equals方法
         * */
public class demo2_ArrayList {

    public static void main(String[] args) {
        ArrayList list = new ArrayList(); //创建集合对象
        list.add(new person("张三",20));
        list.add(new person("张三",20));
        list.add(new person("张三",20));
        list.add(new person("张三",20));
        list.add(new person("李四",20));
        list.add(new person("赵文",20));
        list.add(new person("李四",20));
        ArrayList newlist =getSing(list);

        System.out.println(newlist);

    }
    public static ArrayList getSing(ArrayList list){
        ArrayList newlist = new ArrayList<>();//创建新集合
        Iterator it = list.iterator();    //根据传入的集合(老集合)获取迭代器
        while (it.hasNext()) {       //遍历老集合
            Object obj1= it.next();  //记录每一个元素
            if (!newlist.contains(obj1)) { //如果新集合不包含老集合中的元素
                newlist.add(obj1);  //将该元素添加
            } 
        }
        return newlist;
    }
}

//第二个包
public class person {
    private String name;
    private int 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 person(String name, int age) {
        super();
        this.name = name;
        this.age = age;
    }
    public person() {
        super();
        // TODO Auto-generated constructor stub
    }
    @Override
    public String toString() {
        return "person [name=" + name + ", age=" + age + "]";
    }
    @Override
    public boolean equals(Object obj1) {
        person p=(person)obj1;
        return this.name.equals(p.name) && this.age == p.age;
    }
}

 

LinkList的特有功能

　　public void addFirst( E e)及addFirst(E e)

　　public E getFirst( )及getLast( )

　　public E removFirst( ) 及public E remoLast( )　　

　　public E get(int index)

public class demo3_LinkedList {

    public static void main(String[] args) {
        demo1();
        LinkedList list= new LinkedList();
        
    }

    public static void demo1() {
        LinkedList list= new LinkedList();
        list.addFirst("a");  //添加
        list.addFirst("b");
        list.addFirst("c");
        list.addLast("z");
        
        System.out.println(list);
        //System.out.println(list.getFirst());//获取
        //System.out.println(list.getLast());
        System.out.println(list.removeFirst());//删除
        System.out.println(list.get(1));
        System.out.println(list);
    }

}

 

栈和队列数据结构

栈：

　　先进后出

队列：

　　先进先出

 

LinkedList模拟栈数据结构的集合并测试

package tan.jung.list;

import java.util.LinkedList;

import org.xml.sax.ErrorHandler;

public class demo4_LinkedList {

    public static void main(String[] args) {
        //demo1();
        Stack s=new Stack();
        s.in("a");  //进栈
        s.in("b");
        s.in("c");
        s.in("d");
        
        while (!s.isEmpty()) {  //判断栈是否为空
            System.out.println(s.out());//弹栈
            
        }
        

    }

    public static void demo1() {
        LinkedList list= new LinkedList();
        list.addLast("a");
        list.addLast("b");
        list.addLast("c");
        list.addLast("d");
/*        System.out.println(list);
        System.out.println(list.removeLast());
        System.out.println(list.removeLast());
        System.out.println(list.removeLast());
        System.out.println(list.removeLast());*/
         while (!list.isEmpty()) {  //如果不为空
            System.out.println(list.removeLast());
            
        }
    }

}

//第二个包
package tan.jung.list;

import java.util.LinkedList;

public class Stack {
    private LinkedList list =new LinkedList();
    
    //模拟进栈方法
    public void in(Object obj){
        list.addLast(obj);
    }
    //模拟出栈
    public Object out(){
      return list.removeLast();
    }
    public boolean isEmpty(){
        return list.isEmpty();
    }
}

 

泛型generic

泛型的好处：

　　提高安全性(将运用期的错误转换到编译器)

　　省去强转的麻烦

泛型基本使用：

　　< >中放的必须是引用数据类型

泛型使用注意事项

　　前后的泛型必须一致，或者后面的泛型可以省略不写(1.7的新特性菱形泛型)

 

package tan.jung.generic;

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

import tan.jung.list.person;

public class demo1_generic {

    public static void main(String[] args) {
        //demo1();
        //ArrayList<person> list =new ArrayList<object>();//集合的泛型要保证前后的数量类型一致
        //ArrayList<person> list =new ArrayList<>();//1.7版本的新特性，菱形泛型
        ArrayList<object> list =new ArrayList<>(); //泛型最好不要定义成object，没有意义
        

    }

    public static void demo1() {
        ArrayList<person> list =new ArrayList<person>();
//        list.add("a");
//        list.add(true);
//        list.add(100);
        list.add(new person("谭某",20));
        list.add(new person("某某",22));
        
         Iterator<person> it1=list.iterator();
         while (it1.hasNext()) {
//             person p1=it1.next();
            //System.out.println(it1.next().getName()+"..."+it1.next().getAge());
            //next方法只能调用一次，如果调用多次会将指针向后移动多次
            person p1=it1.next();
            System.out.println(p1.getName()+"..."+p1.getAge());
        }
    }

}

 

 

泛型的由来

　　泛型的由来：通过object转型问题引入

　　早起的object类型可以接受任意的对象类型，但是在实际色使用中。会有类型转换的问题，也就存在隐患，所以java提供了泛型来解决这个安全问题

 

泛型类概述

　　把泛型定义在类上

定义格式

　　public class 类名<泛型类型1，...>

注意事项

　　泛型类型必须是引用类型

 

泛型的方法

　　把泛型定义在方法上

　　public <泛型类型> 返回类型 方法名 (泛型类型 变量名)

 

泛型接口

　　把泛型定义在接口

　　public interface 接口名<泛型类型>

public class demo4_generic {

    public static void main(String[] args) {
        

    }

}
interface Inter<T>{
    public void show(T t);
}
    /*class demo implements Inter<String>{

        @Override
        public void show(String t) {
            System.out.println(t);            
        }        
    }*/

class demo<T> implements Inter<T>{  //没有必要再实现接口的时候给自己类加泛型

        @Override
        public void show(T t) {
            System.out.println(t);
            
        }
    
}

 

泛型通配符< ？>

　　任意类型，如果没有明确，那么就是object以及任意的java类了

？ extends E

　　向下限定，E及其子类

？super E

　　向上1限定，E及其父类

public class demo_Generic {
    public static void main (String args []){
        //List<?> list = new ArrayList<Integer>(); //？代表任意类型 当右边的泛型是不确定时，左边可以指定为?
        ArrayList<person> list1= new ArrayList<>();
        list1.add(new person("张三",23));
        list1.add(new person("李四",24));
        list1.add(new person("赵八",28));
        
        ArrayList<Student> list2=new ArrayList<>();
        list2.add(new Student("六六",26));
        list2.add(new Student("七七",27));
        
        list1.addAll(list2);
        System.out.println(list1);
        
    }
}

 

Foreach

public class demo1_Foreach {
    /*   增强for概述
     *              简化数组和Collection集合的遍历
     *   格式：
     *         for（元素数据类型 变量: 数组或者Collection集合）{
     *             使用变量即可，该变量就是元素
     *             } 　　　*   增强for循环底层依赖的是迭代器（Iterator）
     * */
    public static void main(String[] args) {
        int [] arr={1,2,3,4,5};
        /*for (int i : arr) {
            System.out.println(i);
        }*/
        for (int i : arr) {
            System.out.println(i);
        }
        
        ArrayList<String> list =new ArrayList<>();
        list.add("a");
        list.add("b");
        list.add("c");
        
        for (String string : list) {
            System.out.print(string);
        }
    }

}

 

三种迭代

　　普通for循环，可以删除，但是要索引--

　　迭代器，可以删除，但是必须使用迭代器自身的remove方法，否则会出现并发修改异常

　　增强for循环不能删除

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

public class demo2 {

    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();
        list.add("a");
        list.add("b");
        list.add("b");
        list.add("c");
        list.add("d");
        
        //1.普通for循环删除，索引要--
        /*for (int i = 0; i < list.size(); i++) {
            if ("b".equals(list.get(i))) {
                list.remove(i--);  //通过索引删除元素
            }
        }*/
        
        //2.迭代器删除
        Iterator<String> it1=list.iterator();
        while (it1.hasNext()) {
            if ("b".equals(it1.next())) {
                //list.remove("b");         
            //不能用集合的删除犯法，因为迭代器过程中如果修改会出现并发修改异常
                 
                //it1.remove();
            }
            
        }
        for(Iterator<String> it2=list.iterator();it2.hasNext();){ 
            if ("b".equals(it2.next())) {
                //list.remove("b");         
            //不能用集合的删除犯法，因为迭代器过程中如果修改会出现并发修改异常
                 
                //it2.remove();
            }
        }
        
        //3.增强for循环  ,不能删除，只能遍历
        for (String string : list) {
            if ("b".equals(string)) {
                list.remove("b");
            }
        }
        System.out.println(list);
    }

}

 

静态导入

格式：

　　import static 包名..，类名.方法名

注意事项

　　方法必须是静态的，如果有多个同名的静态方法，容易不知道使用谁?这个时候要使用，必须加前缀，由此可见，意义不太，所以一般不用

import static java.util.Arrays.sort;

import javax.naming.ldap.SortControl;

public class demo3_static {

    public static void main(String[] args) {
        int [] arr ={11,22,44,66,33,55};
        sort(arr);  //排序
        //System.out.println(Arrays.toString(arr));

    }
    public static sort(int [] arr){
        
    }
}

 

可变参数

　　定义方法的时候不知道该定义多少个数

格式：

　　修饰符 返回值类型 方法名 (数据类型... 变量名){ }

注意事项：

　　这里的变量其实是一个数组

　　如果一个方法有可变参数，并且有多个参数，那么，可变参数肯定是最后一个

public class demo4_ChangeableArgs {

    public static void main(String[] args) {
        int [] arr={11,22,33,44,55};
        print(11,22,33,44,55);
        System.out.println("----------");
        //print();

    }
    /*public static void print(int [] arr){
        for (int i : arr) {
            System.out.println(i);
        }
    }*/
    public static void print(int x,int ... arr){  //可变参数是一个数组
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }
    }
}

 

Arrays工具类的asList( )方法

import java.util.List;
import java.util.ArrayList;
import java.util.Arrays;

public class demo5_AsList {
     //数组转换成集合,数组转换成集合虽然不能增加或减少元素，但是可以用集合的思想操作数组，也就是说可以使用其他集合中的方法
    public static void main(String[] args) {
        //demo1();
        //demo2();
        //demo3();
        
        //集合转数组，加泛型
        ArrayList<String> list = new ArrayList<>();
        list.add("a");
        list.add("b");
        list.add("c");
        list.add("d");
        
        String [] arr=list.toArray(new String [10]);
        //当集合转换数组时，数组长度如果小于等于集合的size时，转换后的数组长度等于集合的size
        //如果数组的长度大于了size，分配的数组长度就和你指定的长度一样
        
        for (String string : arr) {
            System.out.println(string);
        }
        
    }

    public static void demo3() {
        Integer [] arr={11,22,33,44,55};
        List<Integer> list=Arrays.asList(arr);//将数字转换成集合，数组必须是引用数据类型
        System.out.println(list);
    }

    public static void demo2() {
        int [] arr={11,22,33,44,55};
        List<int[]> list=Arrays.asList(arr); //基本数据类型的数组转换成集合，会将整个数组当做一个对象转换
        System.out.println(list);
    }

    public static void demo1() {
        String [] arr={"a","b","c","d"};
        List<String> list=Arrays.asList(arr);  //将数字转换成集合
        //list.add("f");                        //不能添加
        System.out.println(list);
    }

}

 

集合嵌套ArrayList嵌套ArrayList

package tan.jung.jdk5;

import java.util.ArrayList;

import tan.jung.list.person;

public class demo6_ArrayListArrayList {

    public static void main(String[] args) {
        ArrayList<ArrayList<person>> list =new ArrayList<>();
        ArrayList<person> first = new ArrayList<>(); //创建第一个班级
        first.add(new person("嘿嘿",18));
        first.add(new person("嘻嘻",20));
        first.add(new person("hh",22));
        
        ArrayList<person> second = new ArrayList<>(); //创建第一个班级
        second.add(new person("大力",19));
        second.add(new person("美丽",21));
        second.add(new person("ss",23));
        
        //将班级天机到学科集合中
        list.add(first);
        list.add(second);
        
        //遍历班级集合
        for (ArrayList<person> a : list) {
            for (person person : a) {
                System.out.println(person);
            }
        }
    }

}

 

来源：https://www.cnblogs.com/JungTan0113/p/10926340.html