• 大数据Java基础——集合（泛型，增强for遍历，静态导入，集合嵌套）

    目录

    Arrays工具类中的一个方法

    泛型概述及使用

    为什么会有泛型呢?

    a.通过案例引入

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

    泛型的语句定义格式

    <引用数据类型> 括号中的数据类型只能是引用数据类型

    例：创建一个List 集合对象

    ArrayList list = new ArrayList<>();

    泛型为String，这样集合只能去添加String类型的元素。

    泛型的好处

    a.将运行时期出现的问题提前到编译时期

    b.不需要做强制类型转换

    c.优化了代码，减少出错的机会

    泛型应用

    泛型类

    把泛型定义在类上

    格式:public class 类名<泛型类型1,…>

    注意:泛型类型必须是引用类型

    //这里<>里面的内容仅仅表示使用的一种参数数据类型，参数类型使一种变量，可以使用任意符合标识符规则的名字
public class GenericTest2 {
    private A name;

    public void setName(A name) {
        this.name = name;
    }

    public A getName() {
        return name;
    }
}

    泛型方法

    把泛型定义在方法上

    格式:public <泛型类型> 返回类型 方法名(泛型类型 .)

    class Generic{
    //泛型方法
    public  void show(B b){   //B代表你传任意类型数据它就变成什么类型的数据
        System.out.println(b);
    }
}
public class GenericTest3 {
    public static void main(String[] args) {
       //创建Generic类的对象
        Generic generic = new Generic();
        generic.show("sad23");      //可以传任意类型数据
        generic.show(223);
        generic.show(2322.232);
    }
}

     

    泛型接口

    把泛型定义在接口上

    格式:public interface 接口名<泛型类型1…>

    //泛型接口
interface Generic1{
    void show(C c);
}
//创建类实现接口
class Ter implements Generic1{
   //重写接口的方法
    @Override
    public void show(C c) {
        System.out.println(c);
    }
}
//测试
public class GenericTest4 {
    public static void main(String[] args) {
        //创建Ter类对象
        Ter s = new Ter<>();
        s.show("sad");
    }
}

     

    泛型高级（通配符）

    1.泛型通配符

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

    //泛型通配符 任意类型，如果没有明确，那么就是Object以及任意的Java类了
        ArrayList list1= new ArrayList();    
        ArrayList list2 = new ArrayList();
        ArrayList list3 = new ArrayList();

    通配符使集合能存放任意类型的数据

    2.  ? extends E

    向下限定，E及其子类

    class Teacher{}  //创建老师类
class Student extends Teacher{}  //创建学生类继承老师类

public class GenericTest1 {
    public static void main(String[] args) {
          //  ? extends E 向下限定，E及其子类
        ArrayList list1=new ArrayList();  //存放自身类型数据
        ArrayList list2=new ArrayList();  //存放子类类型数据

    3.  ? super E

    向上限定，E及其父类

    //? super E  向上限定，E及其父类
        ArrayList list1 = new ArrayList(); //存放自身类型数据
        ArrayList list2 = new ArrayList(); //存放父类类型数据 

    增强for概述及使用
     

    增强for概述
     

    简化数组和Collection集合的遍历
     

    格式： for(元素数据类型 变量 : 数组或者Collection集合) {  
     

    使用变量即可，该变量就是元素      }
     

    好处：简化遍历
     

    注意事项：增强for的目标要判断是否为null
     

    增强for循环使用
     

    例：遍历数组   
     

    public class ForTest1 {
    public static void main(String[] args) {
        //创建普通数组
        int[] arr ={23,2,332,34};

        //普通for循环遍历
        for(int i=0;i
     

     

     
     

       同理也能遍历集合
     

    import java.util.ArrayList;

public class ForTest2 {
    public static void main(String[] args) {
        //创建list集合
        ArrayList list = new ArrayList<>();

        //向集合添加元素
        list.add("java");
        list.add("hive");
        list.add("bigdata");
        list.add("flink");

        //增强for循环遍历,先判断集合是否为空
        if (list!=null) {
            for (String s : list) {
                System.out.println(s);
            }
        }else {
            System.out.println("该集合为空");
        }
    }
}
     

     

     
     

    静态导入概述及使用
     

    静态导入概述
     

    格式：import static 包名….类名.方法名;
     

    可以直接导入到方法的级别
     

    例：静态导入Math方法
     

    import static java.lang.Math.abs; //静态导入Math的abs方法
public class StaticTest1 {
    public static void main(String[] args) {
        //没导保之前调用Math方法
        System.out.println(Math.abs(-233));   //求绝对值

        //静态导入之后，不用写类名，直接写方法名 (如在最上方导入：import static java.lang.Math.abs; ）
        System.out.println(abs(-233));
    }
}
     

     

     
     

     

    注意事项
     

    a,方法必须是静态的
     

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

    c.可以导入自己创建的方法，但方法必须是静态的，如果导入方法名与本类方法冲突，将调用本类方法（若还想使用静态导入的方法，需补齐导入方法包的路径）
     

    例  ：
     

    先创建一个公共类
     

    public class Static2 {
    public static void show(){
        System.out.println("Static2的静态方法");
    }
}
     

    再创建测试类，静态导入方法
     

    import static com.shujia.ys.day19.Static2.show;  //静态导入方法（这是我创建类的路径）
public class StaticTest2 {
    public static void main(String[] args) {

        show();  //虽然静态导入了，但方法名与本类方法名冲突，需补齐路径
        com.shujia.ys.day19.Static2.show();
    }
    public static void show(){
        System.out.println("本类中的静态方法");
    }
}
     

     

     
     

     

    可变参数概述及使用
     

    可变参数概述
     

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

    格式
     

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

    注意事项
     

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

    例：创建方法求多个数的和
     

    public class VarargsTest1 {
    public static void main(String[] args) {
        int a=10;
        int b=20;
        int c=30;
        int d=40;

        sum(a,c);   //调用该方法能求任意数的和
        sum(a,c,b,d);
        sum(c,c,c);
    }
    public static void sum(int...ints){  //用可变参数创建求和方法 变量名ints是形成的数组
        //增强for循环遍历
            int sum=0;
        for(int i:ints){
            sum=sum+i;
        }
        System.out.println(sum);
    }
}
     

     

     
     

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

    例：创建方法求学生任意成绩和
     

    public class VarargsTest2 {
    public static void main(String[] args) {
        
        sum("student1",55,65,78);
        sum("student2",55,66,78,34);
        sum("student3",55,32);
    }
    public static void sum(String s,int...ints){  //可变参数放在后面
        //增强for循环遍历
        int sum=0;
        for(int i:ints){
            sum=sum+i;
        }
        System.out.println(s+":"+sum);
    }
}
     

     

     
     

     

    Arrays工具类中的一个方法
     

    public static  List asList(T... a)    数组转成集合的方法
     

    例：
     

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

public class ArrayListTest1 {
    public static void main(String[] args) {

        //数组————>ArrayList集合
        List strings = Arrays.asList("java", "hive", "flink", "spark");
        //增强for遍历
        for(String s:strings){
            System.out.println(s);
        }
    }
}
     

     

     
     

    集合的嵌套
     

    例：用list集合嵌套实现：一个学校有两个班级，两个班级学生的遍历
     

    首先封装一个公共的学生类   (不会看   封装 ）
     

    public class Student2 {
    private String name;
    private int age;

    public Student2() {}
    public Student2(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }
    public int getAge() {
        return age;
    }

    public void setName(String name) {
        this.name = name;
    }
    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "Student2{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}
     

    再创建大集合（学校）添加两个小集合（班级）进行遍历
     

    import java.util.ArrayList;

public class ArrayListTest2 {
    public static void main(String[] args) {
        //创建两个班级集合
        ArrayList class1 = new ArrayList<>();
        ArrayList class2 = new ArrayList<>();

        //创建学生对象
        Student2 s1 = new Student2("student1",18);
        Student2 s2 = new Student2("student2",22);
        Student2 s3 = new Student2("student3",20);
        Student2 s4 = new Student2("student4",19);
        Student2 s5 = new Student2("student5",21);
        Student2 s6 = new Student2("student6",20);

        //向集合添加学生对象
        class1.add(s1);
        class1.add(s2);
        class1.add(s3);
        class2.add(s4);
        class2.add(s5);
        class2.add(s6);

        //创建学校集合，把两个班级集合添加进去
        ArrayList> school = new ArrayList<>();
        school.add(class1);
        school.add(class2);

        //增强for循环遍历集合 （看不到学生对应的班级）
        for (ArrayList s:school){  //先遍历school中的班级集合
            for (Student2 t :s){   //再遍历班级中的学生对象
                System.out.println(t.getName()+"-----"+t.getAge());
            }
        }
        System.out.println("========分界线==========");

        //普通for循环遍历  （能分别遍历班级）
        for (int i=0;i
     

     

     
     

    +泛型
    
                
                    
                

                
  • 

                    相关阅读:
    
                    
聊一聊redis十种数据类型及底层原理                            
    
在Vue中体验LeanCloud无后台轻量级数据存储服务                            
    
docker - window Docker Desktop升级                            
    
Python——类和对象、魔术方法（day07）                            
    
全面整理！机器学习常用的回归预测模型                            
    
CentOS 7 下升级 OpenSSL + OpenSSH【在线 yum 安装依赖】                            
    
后端面试问题（学习版）                            
    
Rasa 3.x 学习系列-使用查找表改进实体提取                            
    
【漏洞复现】泛微e-office OfficeServer2.php 存在任意文件读取漏洞复现                            
    
Python语义分割与街景识别（1）：理论学习                            
    
                        
                
    • 
                
  • 
                    原文地址：https://blog.csdn.net/lt_xiaodou/article/details/126135887
                
    •