大数据笔记9—java基础篇5（API)

内容导读

互联网集市收集整理的这篇技术教程文章主要介绍了大数据笔记9—java基础篇5（API)，小编现在分享给大家，供广大互联网技能从业者学习和参考。文章包含18745字，纯文字阅读大概需要27分钟。

内容图文

java_API

• API
• • String类
  • • 创建字符串对象的区别对比
    • String字符串的特点
  • 字符串的比较
• 例题
• • 例题1.
  • 例题2遍历字符串
  • 例题3.案例 ：统计字符次数
  • 例题4.案例 ：手机号屏蔽
  • 例题5.需求：替换关键字
  • 例题6.
  • 例题7.
  • 例题8.字符串返回
• 综合案例!
• 关键字
• • final
  • static
  • • **概述**
    • **特点**
  • 抽象类
  • • **入门案例**
    • **抽象类的特点**
    • **抽象类的成员特点**
  • **接口**
  • • **1 概述**
    • **2 特点**
    • **3 成员特点**
    • **4 类与接口之间的关系**
  • 接口案例1
  • 接口案例2
  • 接口案例3
  • 包
  • • **1简述层**
    • **2格式**
    • **3 常见分类**
  • **导包**
  • • 概述
    • **格式**
  • 权限修饰符
  • • 概述
    • 总结

苟有恒，何必三更眠五更起； 最无益，莫过一日曝十日寒。

API

Java API ：指的就是 JDK 中提供的各种功能的 Java类
这些类将底层的实现封装了起来，我们不需要关心这些类是如何实现的，
只需要学习这些类如何使用即可，我们可以通过帮助文档来学习这些API如何使用

String类

创建字符串对象的区别对比

以"" 方式给出的字符串,只要字符序列相同(顺序和大小写),无论在程序代码中出现几次,JVM都只会进阿里一个String对象,并在字符串常量池中维护

字符串常量池

当时用双引号创建字符串对象的时候,系统会检查该字符串师傅在字符串常量池中存在

不存在:创建

存在:不会直接创建而是直接服用

通过new 创建的字符串对象,每一次new都会申请一个内存空间,虽然内容相同,但是地址值不同

 char[] chs = {'a', 'b', 'c'};
 String s1 = new String(chs);
 String s2 = new String(chs);

上面的代码中，JVM会首先创建一个字符数组，然后每一次new的时候都会有一个新的地址

结论：双引号创建的字符串对象，在字符串常量池中存储，通过构造方法创建的字符串对象，在堆内存中存储

String字符串的特点

Java 程序中所有的双引号字符串，都是 String 类的对象
字符串不可变，它们的值在创建后不能被更改
虽然 String 的值是不可变的，但是它们可以被共享

图片上创建两个对象不严谨,如果第一个是bcd跟abc不一样的话就严谨了

只要字符串之间进行拼接,就会生成stringbuilder对象,然后去调用append方法完成拼接

拼接后,再调用toString方法转换成String.

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Ebu7V86P-1617109929164)(file:///C:\Users\dell\AppData\Roaming\Tencent\Users\1392068711\QQ\WinTemp\RichOle\PA}PRL((D3QO3[B93)]Q}]`C.png)

常量优化机制

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-lr8t4YBj-1617109929169)(file:///C:\Users\dell\AppData\Roaming\Tencent\Users\1392068711\QQ\WinTemp\RichOle\BPHLR]}[$_BB_NQEINP7WZ5.png)]

字符串的比较

使用==作比较

基本类型: 比较的是数据值是否相同

引用类型: 比较的是地址值是否相同

字符串是对象，它比较内容是否相同，是通过一个方法来实现的，这个方法叫：equals()

例题

例题1.

需求：已知用户名和密码，请用程序实现模拟用户登录。

? 总共给三次机会，登录之后，给出相应的提示

判断是否相等用 username.equals(un)

 public static void main(String[] args) {
     String username = "admin";
     String password = "123";
     for (int i = 1; i <=3; i++) {
     Scanner sc = new Scanner(System.in);
     System.out.println("请输入账号");
     String un  = sc.nextLine();
     System.out.println("请输入密码");
     String ps  = sc.nextLine();
     if(username.equals(un) && password.equals(ps) ){
         System.out.println("恭喜!");
         break;
     }else{
         if(i == 3){
             System.out.println("您没有机会了"
         }else{
             System.out.println("你还有"+(3 - i)+"次机会重新输入");
        
     }
    
 }

例题2遍历字符串

需求: 键盘录入一个字符串,使用程序实现在控制台遍历该字符串

方法为 st.charAt(i);

public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入一个字符串");
        String st = sc.nextLine();
        for(int i=0; i<st.length(); i++) {
            st.charAt(i);  // 就是指定索引处的字符值
            System.out.println(st.charAt(i));
        }

    }

例题3.案例 ：统计字符次数

需求：键盘录入一个字符串，统计该字符串中大写字母字符，小写字母字符，数字字符出现的次数(不考虑其他字符)

范围:包前不包后

public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入一个字符串");
        String st = sc.nextLine();
        int min=0;
        int max=0;
        int num=0;
        for(int i=0; i<st.length(); i++) {
            st.charAt(i);  // 就是指定索引处的字符值

            if(st.charAt(i)>'a' && st.charAt(i)<='z'){
                min++;
            }else if(st.charAt(i)>'A' && st.charAt(i)<='Z'){
                max++;
            }else if(st.charAt(i)>'0' && st.charAt(i)<='9'){
                num++;
            }
        }
        System.out.println("大写字母:"+max+"小写字母:"+min+"数字:"+num);
    }

例题4.案例 ：手机号屏蔽

需求：以字符串的形式从键盘接受一个手机号，将中间四位号码屏蔽
最终效果为：156****1234

调用的方法为st.substring(0,3); 取前三值和后四位值

 public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入手机号:");
        String st = sc.nextLine();
        String beforenum = st.substring(0,3);
        String afterenum = st.substring(7);
        System.out.println(beforenum+"****"+afterenum);

    }

例题5.需求：替换关键字

键盘录入一个 字符串，如果字符串中包含（TMD），则使用***替换

    思路：
    1. 键盘录入一个字符串，用 Scanner 实现
    2. 替换敏感词
            String replace(CharSequence target, CharSequence replacement)
            将当前字符串中的target内容，使用replacement进行替换，返回新的字符串
    3. 输出结果

public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入一个字符串");
        String st = sc.nextLine();
        String MSG = st.replace("TMD","***");
        System.out.println(MSG);

    }

例题6.

需求：以字符串的形式从键盘录入学生信息，

例如：“张三 , 23”
从该字符串中切割出有效数据,封装为Student学生对象
思路：

1.编写Student类，用于封装数据

2.键盘录入一个字符串，用 Scanner 实现
3.根据逗号切割字符串，得到（张三）（23）
String[] split(String regex) ：根据传入的字符串作为规则进行切割
将切割后的内容存入字符串数组中，并将字符串数组返回
4.从得到的字符串数组中取出元素内容，通过Student类的有参构造方法封装为对象
5.调用对象getXxx方法，取出数据并打印。

需要获取name和age的值

public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        String  user = sc.nextLine();
        String[]  split= user.split(",");
        String name = split[0];
        String age = split[1];
        Student su = new Student(name,age);
        System.out.println(su.toString());
    }


public class Student {
    String name;
    String age;

    public Student() {
    }

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

    public String getName() {
        return name;
    }

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

    public String getAge() {
        return age;
    }

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

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

例题7.

需求：键盘接受一个字符串，程序判断出该字符串是否是对称字符串，并在控制台打印是或不是

? 对称字符串：123321、111
? 非对称字符串：123123

public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入一个字符串:");
        String st = sc.nextLine();
        StringBuilder  sb1 = new  StringBuilder(st);
        StringBuilder  sb2 = sb1.reverse();
        String st2 = sb2.toString();
        if(st2.equals(st)){
            System.out.println("是对称字符串");
        }else
            System.out.println("不是对称字符串");

例题8.字符串返回

需求：定义一个方法，把 int 数组中的数据按照指定的格式拼接成一个字符串返回

? 调用该方法，并在控制台输出结果。
? 例如，数组为int[] arr = {1,2,3};
? 执行方法后的输出结果为：[1, 2, 3]

思路：
1. 定义一个 int 类型的数组，用静态初始化完成数组元素的初始化
2. 定义一个方法，返回值类型 String，参数列表 int[] arr
3. 在方法中用 StringBuilder 按照要求进行拼接，并把结果转成 String 返回
4. 调用方法，用一个变量接收结果
5. 输出结果

public static void main(String[] args) {
int[] arr = {1,2,3};
    //4. 调用方法，用一个变量接收结果
    String printStr = getString(arr);
    //5. 输出结果
    System.out.println("printStr = " + printStr);
}

 public static String getString(int[] arr){
	StringBuilder sb= new StringBuilder("[");
     for(int i = 0; i < arr.length; i++){
         if(i == arr.length-1){
             sb.append(arr[i]).append("]");
         }else{
             sb.append(arr[i]).append(",");
         }
     }
           return sb.toString();
          
}
}

综合案例!

在控制台上打印输出每一个选项的功能

利用ArrayList集合来做

做两个类 一个student类 一个studentTest类

关键字

final

final是一个关键字, 表示最终的意思, 可以修饰类, 成员变量, 成员方法.

? 修饰的类: 不能被继承, 但是可以继承其他的类.

? 修饰的变量: 是一个常量, 只能被赋值一次.

? 修饰的方法: 不能被子类重写.

static

概述

static是一个关键字, 表示静态的意思, 可以修饰成员变量, 成员方法.

特点

1.随着类的加载而加载.

2.优先于对象存在.

3.被static修饰的内容, 能被该类下所有的对象共享.

解释: 这也是我们判断是否使用静态关键字的条件.

4.可以通过**类名.**的形式调用.

抽象类

Java中, 一个没有方法体的方法应该定义为抽象方法, 而类中如果有抽象方法, 该类必须定义为抽象类.

abstract

抽象类跟普通类只是多了一个abstract关键字,可以不在子类中重写方法,其他的没什么区别

入门案例

需求

创建抽象类Animal.

在该类中定义抽象方法eat()

参考代码

//抽象的动物类.
public abstract class Animal {
//抽象方法, 吃.
public abstract void eat();
}

抽象类的特点

1抽象类和抽象方法必须用abstract关键字修饰.

//抽象类
public abstract class 类名{ }

//抽象方法
public abstract void eat();

2抽象类中不一定有抽象方法, 有抽象方法的类一定是抽象类.

3抽象类不能实例化.

– 那抽象类如何实例化呢?

– 可以通过多态的方式, 创建其子类对象, 来完成抽象类的实例化. 这也叫: 抽象类多态.

4抽象类的子类:

如果是普通类, 则必须重写父抽象类中所有的抽象方法.

如果是抽象类, 则可以不用重写父抽象类中的抽象方法.

抽象类的成员特点

抽象类中可以有变量, 常量, 构造方法, 抽象方法和非抽象方法.

思考: 既然抽象类不能实例化, 那要构造方法有什么用?

答: 用于子类对象访问父类数据前, 对父类数据进行初始化.

接口

1 概述

为了体现事物功能的扩展性，Java中就提供了接口来定义这些额外功能，并不给出具体实现，

简单来说就是某一个类的部分特点显示出来,在类中有的有这些特点,有的没有这些特点.

2 特点

接口用interface关键字修饰.

类和接口之间是实现关系, 用implements关键字表示.

接口不能实例化.

– 那接口如何实例化呢?

– 可以通过多态的方式, 创建其子类对象, 来完成接口的实例化. 这也叫: 接口多态.

接口的子类:

如果是普通类, 则必须重写父接口中所有的抽象方法.

如果是抽象类, 则可以不用重写父接口中的抽象方法.

3 成员特点

接口中有且只能有常量或者抽象方法, 原因是因为:

? 成员变量有默认修饰符: public static final

? 成员方法有默认修饰符: public abstract

注意: 因为接口主要是扩展功能的, 而没有具体存在, 所有接口中是没有构造方法的.

记忆: JDK1.8的时候, 接口中加入了两个新的成员: 静态方法, 默认方法(必须用default修饰).

4 类与接口之间的关系

? 类与类之间: 继承关系, 只能单继承, 不能多继承, 但是可以多层继承.

? 类与接口之间: 实现关系, 可以单实现, 也可以多实现. 还可以在继承一个类的同时实现多个接口.

? 接口与接口之间: 继承关系, 可以单继承, 也可以多继承.

总结:

① 抽象类和接口都是用来抽象具体的对象的，但是接口的抽象级别更高。

② 抽象类可以有具体的方法和属性，接口只能有抽象方法和静态常量。

③ 抽象类主要用来抽象级别，接口主要用来抽象功能。

④ 抽象类中，且不包含任何的实现，派生类必须覆盖它们。接口中所有方法都必须是未实现的。

⑤ 接口方法，访问权限必须是公共的 public。

⑥ 接口内只能有公共方法，不能存在成员变量。

⑦ 接口内只能包含未被实现的方法，也叫抽象方法，但是不能用 abstract 关键字。

⑧ 抽象类的访问速度比接口要快，接口是稍微有点慢，因为它需要时间去寻找在类中实现的方法。

⑨ 抽象类，除了不能被实例化外，与普通 java 类没有任何区别。

⑩ 抽象类可以有 main 方法，接口没有 main 方法。

? 抽象类可以用构造器，接口没有。

? 抽象方法可以有 public、protected 和 default 这些修饰符，接口只能使用默认 public。

? 抽象类，添加新方法可以提供默认的实现，不需要改变原有代码。接口添加新方法，子类必须实现。

? 抽象类的子类用 extends 关键字继承，接口用 implements 来实现。? AddTeacher.java

接口案例1

1. 已知有猫类和狗类, 它们都有姓名和年龄, 都要吃饭, 不同的是猫吃鱼, 狗吃肉.
   它们都有跑
   步的功能, 而且仅仅是跑步, 并无任何区别.
   猫独有自己的功能: 抓老鼠catchMouse(), 狗独有自己的功能: 看家lookHome()
   部分的猫和狗经过马戏团的训练后, 学会了跳高jump(), 请用所学, 模拟该知识.

//jump接口
package day11_homework_01;

public interface Jump {
   void Jump();
}
//Animal类
package day11_homework_01;

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

    public Animal() {
    }

    public Animal(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 void eat(){

    }
    public void run(){
        System.out.println("跑步!!!!!!");
    }

    @Override
    public String toString() {
        return "Animal{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}
//Cat类
package day11_homework_01;

public class Cat extends Animal implements Jump{

    public Cat() {
    }

    public Cat(String name, int age) {
        super(name, age);
    }

    @Override
    public void eat() {
        System.out.println("吃鱼");
    }

    public  void catchMouse() {
        System.out.println("抓老鼠");
    }


    @Override
    public void Jump() {
        System.out.println("跳跃");
    }
}

//Dog类
package day11_homework_01;

public  class Dog extends Animal implements Jump{
    public Dog() {
    }

    public Dog(String name, int age) {
        super(name, age);
    }

    @Override
    public void eat() {
        System.out.println("吃骨头");
    }
    void lookHome(){
        System.out.println("看家");
    }

    @Override
    public void Jump() {

    }
}

//Test类
package day11_homework_01;

public class Test {
    public static void main(String[] args) {
        Cat cat = new Cat("tom",3);
        cat.catchMouse();
        cat.eat();
        cat.Jump();
        System.out.println(cat);
        Dog Dog = new Dog("大黄", 3) ;

        Dog.lookHome();
        Dog.eat();
        Dog.Jump();
        System.out.println(Dog);
    }
}

接口案例2

2. 已知有乒乓球运动员(PingPangPlayer)和篮球运动员(BasketballPlayer), 乒乓球教练(PingPangCoach)和篮球教练(BasketballCoach).
   他们都有姓名和年龄, 都要吃饭, 但是吃的东西不同.
   乒乓球教练教如何发球, 篮球教练教如何运球和投篮.
   乒乓球运动员学习如何发球, 篮球运动员学习如何运球和投篮.
   为了出国交流, 跟乒乓球相关的人员都需要学习英语.
   请用所学, 模拟该知识.
   

//Person类
public class Person {
   private String name;
   private int age;

    public Person() {
    }

    public Person(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 String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }

    void eat(){

    }

}


//Test类   只测试老师
public class Test {
    public static void main(String[] args) {
        PingPangCoach ppc = new PingPangCoach("张三丰",23);
        ppc.StudyEnglish();
        ppc.teachPingPang();
        System.out.println(ppc);
        ppc.eat();
    }
}
//PingPangPlayer类
public class PingPangPlayer extends Person implements English{
    public PingPangPlayer() {
    }

    public PingPangPlayer(String name, int age) {
        super(name, age);
    }

    void  PingPangskill(){
        System.out.println("我只会发球和接球!");
    }

    @Override
    public void StudyEnglish() {
        System.out.println("我不装了,我摊牌了,我是乒乓球界的张无忌");
    }
}
//PingPangCoach类
public class PingPangCoach extends Person implements English{
    public PingPangCoach() {
    }

    public PingPangCoach(String name, int age) {
        super(name, age);
    }

    void teachPingPang(){
        System.out.println("教发乒乓球!");
    }

    @Override
    public void StudyEnglish() {
        System.out.println("我不装了,我摊牌了,我是乒乓球界的张三丰");

    }
}


//English接口
public interface English {
    void StudyEnglish();
}
//BasketballCoach
public class BasketballCoach extends Person{
    void teachBasketball(){
        System.out.println("教发篮球!");
    }
}
//BasketballPlayer
public class BasketballPlayer extends Person{
    public BasketballPlayer() {
    }

    public BasketballPlayer(String name, int age) {
        super(name, age);
    }

    void Basketballskill(){
        System.out.println("我只会运球和投球");
    }
}

接口案例3

已知传智播客公司有基础班老师(BasicTeacher)和就业班老师(WorkTeacher), 基础班学生(BasicStudent)和就业班学生(WorkStudent).
他们都有姓名, 年龄, 都要吃饭, 不同的是学生吃牛肉, 老师喝牛肉汤.
老师有自己的额外属性: 工资(salary), 且老师需要讲课(基础班老师讲JavaSE, 就业班老师讲JavaEE, Hadoop, Hive, Scala, Flink, Spark等).
基础班学生学习JavaSE, 就业班学生学习JavaEE, Hadoop, Hive, Scala, Flink, Spark等.
为了扩大就业市场, 跟就业班相关的人员都需要学习英语.
请用所学, 模拟该知识.

//Person
package day11_homework_03;

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

    public Person() {
    }

    public Person(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 String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }

    void eat(){

    }
}
//BasicStudent
package day11_homework_03;

public class BasicStudent extends Person implements Study{

    public BasicStudent() {
    }

    public BasicStudent(String name, int age) {
        super(name, age);
    }

    @Override
    void eat() {
        System.out.println("我,基础班学生,打钱吃牛肉!");
    }

    @Override
    public void Study() {
        System.out.println("我,基础班学生,JavaSE");
    }
}

//BasicTeacher
package day11_homework_03;

public class BasicTeacher extends Person  implements teach{
    public BasicTeacher() {
    }

    public BasicTeacher(String name, int age) {
        super(name, age);
    }

    @Override
    void eat() {
        System.out.println("我基础班上海滩文强老师,牛肉汤伺候着!");
    }

    @Override
    public void teach() {
        System.out.println("在基础班我教JavaSE!");
    }
}




//Study
package day11_homework_03;

public interface Study {
    void Study();
}

//teach
package day11_homework_03;

public interface teach {
    void teach();
}

//Test
package day11_homework_03;

public class Test {
    public static void main(String[] args) {
        BasicStudent bs = new BasicStudent("周星宇",22);
        bs.eat();
        bs.Study();
        System.out.println(bs);
        System.out.println("--------------");
        WorkStudent ws = new WorkStudent("周星宇",22);
        ws.eat();
        ws.Study();
        System.out.println(ws);
    }
}

//WorkStudent
package day11_homework_03;

public class WorkStudent extends Person implements Study{

    public WorkStudent() {
    }

    public WorkStudent(String name, int age) {
        super(name, age);
    }


    void eat() {
        System.out.println("我,就业班学生,打钱吃牛肉!");
    }

    @Override
    public void Study() {
        System.out.println("我,就业班学生,学会了JavaEE, Hadoop, Hive, Scala, Flink, Spark");
    }
}

//WorkTeacher
package day11_homework_03;

public class WorkTeacher extends Person implements teach{

    public WorkTeacher() {
    }

    public WorkTeacher(String name, int age) {
        super(name, age);
    }


    @Override
    void eat() {
        System.out.println("我斧头帮就业办老师,牛肉汤赶紧的!");
    }
    @Override
    public void teach() {
        System.out.println("就业办老师我教JavaEE, Hadoop, Hive, Scala, Flink, Spark等");
    }
}

包

1简述层

包(package)就是文件夹, 用来对类进行分类管理的. 例如:

? 学生的增加, 删除, 修改, 查询.

? 老师的增加, 删除, 修改, 查询.

? 其他类的增删改查…

? 基本的划分: 按照模块和功能划分.

? 高级的划分: 就业班做项目的时候你就能看到了.

2格式

package 包名1.包名2.包名3; //多级包之间用.隔开

注意:

package语句必须是程序的第一条可执行的代码.

package语句在一个.java文件中只能有一个.

3 常见分类

? 按照功能分

– com.itheima.add

? ? AddStudent.java

? ? AddTeacher.java

? 按照模块分

– com.itheima.student

? ? AddStudent

? ? DeleteStudent

– com.itheima.teacher

? ? AddTeacher

? ? DeleteTeacher

导包

概述

不同包下的类之间的访问，我们发现，每次使用不同包下的类的时候，都需要加包的全路径。比较麻烦。这个时候，java就提供了导包的功能。

格式

import 包名;

import java.util.*; 意思是导入java.util包下所有类, 这样做效率较低, 不推荐使用.

import java.util.Scanner; 意思是导入java.util.Scanner类, 推荐使用. 用谁就导入谁.

权限修饰符

概述

权限修饰符是用来修饰类, 成员变量, 构造方法, 成员方法的, 不同的权限修饰符对应的功能不同. 具体如下:

	public	protected	默认	private
同一个类中	√	√	√	√
同一个包中的子类或者其他类	√	√	√
不同包中的子类	√	√
不同包中的其他类(无关类)	√

总结

访问权限修饰符的权限从大到小分别是: public > protected > 默认 > private

在实际开发中, 如果没有特殊需求, 则成员变量都用private修饰, 其它都用public修饰.

大白话总结四个访问权限修饰符的作用:

private: 强调的是给自己使用.

默认: 强调的是给同包下的类使用.

protected: 强调的是给子类使用.

public: 强调的是给大家使用.

内容总结

以上是互联网集市为您收集整理的大数据笔记9—java基础篇5（API)全部内容，希望文章能够帮你解决大数据笔记9—java基础篇5（API)所遇到的程序开发问题。 如果觉得互联网集市技术教程内容还不错，欢迎将互联网集市网站推荐给程序员好友。

内容备注

版权声明：本文内容由互联网用户自发贡献，该文观点与技术仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容， 请发送邮件至 gblab@vip.qq.com 举报，一经查实，本站将立刻删除。

内容手机端

---