JAVA-（集合详解、ArrayList、Lambda表达式、A

作者: 宁晓鸯 | 来源:发表于2019-08-17 00:58 被阅读0次

心得体会

有些时候学过的东西，若不反复去记得话，真的会忘的，而且如果时间隔得太远，就像新的一样。今天上课的过程中，发现自己好几个知识点都不记得了，哭唧唧~~

今日所学

集合

1.集合基础框架（Collection、Map）
2.collection集合方法
3.List集合的三种遍历方式以及优缺点
4.ArrayList相关方法及操作
5.Lambda表达式
6.基础练习小demo
7.ArrayList自定义排序

具体操作

1.集合基础框架

以下框架只显示我认为常用的^^：

image.png


>---|Collection: 单列集合  
           ---|List: 有存储顺序, 可重复  
                ---|ArrayList:  数组实现, 查找快, 增删慢  
                            由于是数组实现, 在增和删的时候会牵扯到数组增容, 拷贝元素. 所以慢。数组是可以直接按索引查找, 所以查找时较快  
                ---|LinkedList: 链表实现, 增删快, 查找慢  
                            由于链表实现, 增加时只要让前一个元素记住自  己就可以, 删除时让前一个元素记住后一个元  素, 后一个元素记住前一个元素. 这样的增删效率较高但查询时需要一个一个的遍历, 所以效率较低  
                ---|Vector: 和ArrayList原理相同, 但线程安全, 效率略低  
                             和ArrayList实现方式相同, 但考虑了线程安全问  
                                                题, 所以效率略低  
            ---|Set: 无存储顺序, 不可重复  
                ---|HashSet  
                ---|TreeSet  
                ---|LinkedHashSet  
---| Map: 键值对  
        ---|HashMap  
        ---|TreeMap  
        ---|HashTable  
        ---|LinkedHashMap

2.collection集合方法

增加：  
        1：add() 将指定对象存储到容器中, add 方法的参数类型是Object 便于接收任意对象  
        2：addAll() 将指定集合中的元素添加到调用该方法和集合中
  
删除： 
        3：remove() 将指定的对象从集合中删除  
        4：removeAll() 将指定集合中的元素删除

获取  
        5:  size() 获取元素个数

判断  
        6：isEmpty() 判断集合是否为空  
        7：contains() 判断集合何中是否包含指定对象
        8：equals()  集合进行比较      
        9：containsAll() 判断集合中是否包含指定集合  
                           
修改  
        10：clear() 清空集合中的所有元素
  
转成数组  
        10： toArray()   集合转换数组

public class Myclass {
   public static void main(String[] args){
       //定义一个可变数组
        Collection<String> t1=new ArrayList();

       //向可变数组里面添加元素
        t1.add("Jack");
        t1.add("Merry");
        System.out.println(t1);
        System.out.println("---------------");

        //删除一个对象
        t1.remove("Jack");
        System.out.println(t1);
        System.out.println("---------------");

        
        //获取元素个数
        System.out.println(t1.size());
        System.out.println("---------------");

       //判断是否包含一个元素
        if(t1.contains("Merry")){
            System.out.println("有Merry");
        }else{
            System.out.println("没有Merry");
        }
        System.out.println("---------------");

       //判断是否为空
        if(t1.isEmpty()){
            System.out.println("是空的");
        }
        //判断两个集合是否相同
        Collection<String> t2=new ArrayList<>();
        t2.add("Merry");
        t2.add("Jack");
        t2.add("1");
        t2.add("2");
        if(t1.equals(t2)){
            System.out.println("两个集合相同");
        }else{
            System.out.println("两个集合不相同");
        }
       System.out.println("---------------");
        
       //清空
        t1.clear();
        System.out.println(t1);
   }
}

运行结果：

image.png

用toArray()方法将集合转化为数组：

      Collection<String> t1=new ArrayList();
      //向可变数组里面添加元素
       t1.add("Jack");
       t1.add("Merry");
       System.out.println(t1);
       System.out.println("---------------");

       //将集合转化为数组
       Object[] objects=new String[t1.size()];
       t1.toArray(objects);
       System.out.println(objects);

3.List集合的三种遍历方式以及优缺点

1.集合遍历常用方法

hasnext():判断是否有元素
next(): 获取下一个对象
remove(): 删除当前遍历过后的对象

2.第一种遍历方法---使用迭代器（Iterator）来遍历

优点：迭代器提供了操作元素的方法可以在遍历中相应地操作元素
缺点：运行复杂，性能稍差，效率相对其他两种遍历方式较低

public class Myclass {
   public static void main(String[] args){
        Collection<String> t2=new ArrayList<>();
        t2.add("Merry");
        t2.add("Jack");
        t2.add("John");
        t2.add("Cindy");

        Iterator iterator=t2.iterator();
        while(iterator.hasNext()){
            System.out.println(iterator.next());
        }
    }
}

运行结果：

image.png

迭代器错误的遍历方式：!!!!

public class Myclass {
   public static void main(String[] args){
        Collection<String> t2=new ArrayList<>();
        t2.add("Merry");
        t2.add("Jack");
        t2.add("John");
        t2.add("Cindy");

        Iterator iterator=t2.iterator();
        while(iterator.next()!=null){
            System.out.println(iterator.next());
        }
        System.out.println("-------------------");

image.png

3.第二种遍历方法---For

优点：效率最高，遍历快，可以根据自定计数器操作元素
缺点：不适用所有集合，每次都需要在应用程序中手动强转和额外的获得list.size,还有一个缺点就是遍历过程中不允许删除元素

 public static void main(String[] args){
        Collection<String> t2=new ArrayList<>();
        t2.add("Merry");
        t2.add("Jack");
        t2.add("John");
        t2.add("Cindy");

        for(int i=0;i<t2.size();i++){
            System.out.println(((ArrayList<String>) t2).get(i));
        }
}

运行结果：

image.png

3.第三种遍历方法---For-each

优点：代码简洁，不易出错。
缺点：只能做简单的遍历，不能在遍历过程中操作（删除、替换）数据集合。

 public static void main(String[] args){
  Collection<String> t2=new ArrayList<>();
        t2.add("Merry");
        t2.add("Jack");
        t2.add("John");
        t2.add("Cindy");
   //3.for-each 增强for循环 快速循环
        for(String obj:t2){
            System.out.println(obj);
        }
}

运行结果：

image.png

4.ArrayList相关方法及操作

温馨小贴士（以下操作原本是连贯的，我把它分割了，但下面代码的结果受上面代码的影响^^）

add(e)：将指定的元素添加到此列表的尾部
add(int index,element):将制定的元素插入此列表的指定位置

        ArrayList<Integer> score=new ArrayList<>();
        //add(e)
        score.add(2);
        score.add(3);//在末尾添加
        System.out.println(score);
        System.out.println("-------------------------");
        
        //add(int index,element),"add(0,1)"表示将整数1添加到列表的第一位
        score.add(0,1);
        System.out.println(score);

image.png

get(int index):访问指定元素
set(int index,element):用指定的元素替代此列表中指定位置上的元素

 //访问指定元素
        score.get(1);
        System.out.println(score.get(1));
        System.out.println("-------------------------");

        //修改一个元素
        score.set(0,0);//改第几个 用什么去替换
        System.out.println(score);
        System.out.println("-------------------------");

image.png

remove(int index):移除此列表中指定位置上的元素
remove(Object o):移除此列表中首次出现的指定元素
clear():删除所有，清空

        //移除此列表中指定位置上的元素
        score.remove(0);
        System.out.println(score);
        System.out.println("-------------------------");
        
        //删除指定的对象,下面一段demo表示删除列表中所有的整数3
        score.remove((Integer)3);
        System.out.println(score);
        System.out.println("-------------------------");

        score.clear();//删除所有，清空
        System.out.println(score);

image.png

addAll():从指定的位置开始，将指定Collection中所有的元素插入到此列表中，可以用来将另一个集合里面的内容添加到当前集合里
retainAll(Collection c)： 两个集合求交集，只保留交集数据

 ArrayList<Integer> a2=new ArrayList<>();
       a2.add(1);
       a2.add(2);
       a2.add(3);

       //将另一个集合里面的内容添加到当前集合里
        score.addAll(a2);
        System.out.println(score);
        System.out.println("-------------------------");

        ArrayList<Integer> a3=new ArrayList<>();
        a3.add(1);
        a3.add(2);
        score.retainAll(a3);//取两个集合的交集
        System.out.println(score);

image.png

indexOf(object o):访问此列表中首次出现的指定元素的索引，或如果不包含指定元素，则返回-1
lastIndexOf(object o):访问此列表中最后一次出现的指定元素的索引，或如果此列表不包含改索引，则返回-1

   //访问某个对象在集合里面的索引
        ArrayList<Integer> a4=new ArrayList<>();
        a4.add(1);
        a4.add(2);
        a4.add(2);
        a4.add(1);
        System.out.println(a4.indexOf(1));//第一次出现的位置
        System.out.println(a4.lastIndexOf(1));//最后一次出现的位置  //如果没有 返回值是-1
        System.out.println("----------------------------------------------------");

image.png

toArray():按适当顺序（从第一个到最后一个）返回包含此列表中所有元素的数组

 //将ArrayList转化为普通数组
        Object[] objects=new Integer[a4.size()];
        a4.toArray(objects);
        System.out.println(objects);//输出的是地址
        System.out.println("----------------------------------------------------");
        Object[] objects1=a4.toArray();
        for(Object i:objects1){
            System.out.println(i);
        }

image.png

subList():获取某个范围内的子集和

       //获取某个范围内的子集和
        List<Integer> integers=a4.subList(1,2);
        System.out.println(integers);

image.png

5.Lambda表达式

1.removeif()方法

remove():清除满足条件的元素

2.Lambda表达式的语法

基本语法:
(parameters) -> expression
或
(parameters) ->{ statements; }

3.关于Lambda表达式的一个简单例子

       ArrayList <Integer> nums=new ArrayList<>() ;
       nums.add(1);
       nums.add(2);
       nums.add(3);
       nums.add(4);
       //Lambda表达式
       nums.removeIf(obj ->obj % 2==0);
       System.out.println(nums);

image.png

nums.removeIf(obj ->obj % 2==0);

remove()方法里面使用了Lambda表达式,上面句话表示将数组里面能被2整除的数清除
nums里面的数依次被取出，%2判断是否能够整除，如果整除，就移除那个数
由于【2,4】能够整除【2】，所以【2,4】被移除数组，数组里面就只剩下【1,3】

4.Lambda表达式的定义

Lambda表达式也可以成为闭包，把函数作为一个方法的参数

5.使用Lambda表达式的要求

1.必须是接口，这个接口里面只能有一个方法

6.使用Lambda表达式案例

class ArrayClass{
public void test(int[] target,Show s){
for(int obj:target){
s.customShow(element);
     }
   }
 }
//必须是接口， 这个接口里面只能有一个方法
Interface Show{
 void customShow(int element);
}

main函数里

如何使用上诉功能？:

1.定义一个类实现接口

//写一个类实现上段代码的接口
class PXDClass implements Show{
    @Override
    public void customShow(int element) {
        System.out.println(element);
    }
}

main函数里

 //1.使用方式 定义一个类实现接口
       ArrayClass ac=new ArrayClass();
       int[] num={1,2,3,4,5,6};
       PXDClass pc=new PXDClass();
       ac.test(num,pc);

2.使用匿名类

  ArrayClass ac=new ArrayClass();
       int[] num={1,2,3,4,5,6};
       ac.test(num, new Show() {
           @Override
           public void customShow(int element) {
               System.out.println(element);
           }
       });

3.使用Lambda表达式

// 如果参数是一个接口类
     ArrayClass ac=new ArrayClass();
       int[] num={1,2,3,4,5,6};
       ac.test(num,( int element )->{System.out.println(element);});

  //如果只有一个参数 参数类型可以省略
   ArrayClass ac=new ArrayClass();
   int[] num={1,2,3,4,5,6};
    ac.test(num, element -> 
 {System.out.println(element);});

// 如果代码块里面只有一行语句 大括号可以省略
       ArrayClass ac=new ArrayClass();
      int[] num={1,2,3,4,5,6};
      ac.test(num, element ->System.out.println(element));

上述代码执行的结果是一样的

image.png

6.基础练习小demo

1.创建一个类Person:name age属性
2.创建ArrayList对象保存多个Person对象
3.统计年龄大于30的人数
4..统计姓张的人的人数

public class LittleDemo {
   public static void main(String[] args){
       ArrayList<Person> person=new ArrayList<>();
       Person p1=new Person("张三",28);
       Person p2=new Person("李四",33);
       Person p3=new Person("王二",34);
       Person p4=new Person("张四",20);

       person.add(p1);
       person.add(p2);
       person.add(p3);
       person.add(p4);
       int ageCount=0;
       int nameCount=0;
       for(Person person1:person){
           if(person1.age>30){
               ageCount++;
           }
           if(person1.name.contains("张")){
               nameCount++;
           }
       }
       System.out.println(ageCount+" "+nameCount);
}
}
class Person {
    String name;
    int age;
    public Person(String name,int age){
        this.name=name;
        this.age=age;
    }
}

image.png

7.ArrayList自定义排序

1.系统自定义方法排序

 ArrayList<Integer> a1=new ArrayList<>();
       a1.add(2);
       a1.add(1);
       a1.add(4);
       a1.add(3);
       a1.sort(Comparator.comparingInt(Integer::intValue));
       System.out.println(a1);

2.手动创建比较器
1.继承一个类

public class LittleDemo {
   public static void main(String[] args){
   ArrayList<Integer> a1=new ArrayList<>();
       a1.add(2);
       a1.add(1);
       a1.add(4);
       a1.add(3);
    a1.sort(new PXDCompare());
    System.out.println(a1);
  }
}
class PXDCompare implements Comparator{

    //什么时候需要自己手动创建比较器
    //如果系统默认提供的方法不能完成我们的比较
    @Override
    public int compare(Object o, Object t1) {
        int mo=(int)o;
        int mt1=(int)t1;
        return mo-mt1;
    }
}

2.使用匿名类

public class LittleDemo {
   public static void main(String[] args){
   ArrayList<Integer> a1=new ArrayList<>();
       a1.add(2);
       a1.add(1);
       a1.add(4);
       a1.add(3);
       a1.sort(new Comparator<Integer>() {
           @Override
           public int compare(Integer integer, Integer t1) {
               return integer-t1;
           }
       });
System.out.println(a1);
}
}

public class LittleDemo {
   public static void main(String[] args){
   ArrayList<Integer> a1=new ArrayList<>();
       a1.add(2);
       a1.add(1);
       a1.add(4);
       a1.add(3);
      a1.sort((Integer i1,Integer i2)->{
           return i1-i2;
       });
    System.out.println(a1);

JAVA-（集合详解、ArrayList、Lambda表达式、A

心得体会

今日所学

集合

1.集合基础框架（Collection、Map）

2.collection集合方法

3.List集合的三种遍历方式以及优缺点

4.ArrayList相关方法及操作

5.Lambda表达式

6.基础练习小demo

7.ArrayList自定义排序

具体操作

1.集合基础框架

2.collection集合方法

3.List集合的三种遍历方式以及优缺点

1.集合遍历常用方法

2.第一种遍历方法---使用迭代器（Iterator）来遍历

迭代器错误的遍历方式：!!!!

3.第二种遍历方法---For

3.第三种遍历方法---For-each

4.ArrayList相关方法及操作

温馨小贴士（以下操作原本是连贯的，我把它分割了，但下面代码的结果受上面代码的影响^^）

5.Lambda表达式

1.removeif()方法

2.Lambda表达式的语法

3.关于Lambda表达式的一个简单例子

`nums.removeIf(obj ->obj % 2==0);`

4.Lambda表达式的定义

5.使用Lambda表达式的要求

6.使用Lambda表达式案例

6.基础练习小demo

7.ArrayList自定义排序

相关文章

网友评论

延伸阅读

深度阅读

栏目导航

热点阅读