0
点赞
收藏
分享

微信扫一扫

学习java第8天

mm_tang 2022-03-20 阅读 67
java

常用API

api(application Programming interface),应用程序编程接口

Java写好的技术(功能代码),咱们可以直接调用

Oracle也为java提供的这些功能代码提供了相应的api文档(技术使用说明书)

下载api文档:

http://www.oracle.com/technetwork/java/javase/download/index.html

String类定义的变量可以用于存储字符串，同时String类提供了很多操作字符串的功能，我们可以直接使用

String类概述:

String概述:java.lang:String 类代表字符串，String类定义的变量可以用于指向字符串对象，然后操作字符串

java程序中的所有字符串文字都为此类的对象

String类的特点详解:

String其实常被称为不可变字符串类型，它的对象在创建后不能被更改

字符串对象存在哪里?以" "方式给出的字符串对象，在字符串常量池中存储

String是什么,可以做什么?

字符串类型，可以定义字符串变量指向字符串对象

String是不可变字符串的原因?

String变量每次的修改其实都是产生并指向了新的字符串对象

原来的字符串对象都是没有改变的，所以称不可变字符串

String类创建对象的2种方式?

创建字符串对象的2种方式?方式一:直接使用" "定义String name="传智教育";

方式二:通过String类的构造器创建对象.

package string;

public class StringDemo2 {
    public static void main(String[] args) {
        //方式一:直接使用双引号得到字符串对象
        String name="我爱你";
        System.out.println(name);
        //方式二
        //1.public String():创建一个空白字符串对象，不含有任何内容(几乎不用)
        String s1=new String();
        System.out.println();
        //2.public String(String):根据传入的字符串内容，来创建字符串对象
        String s2=new String("我是中国人");
        System.out.println(s2);
        //3.public String(char[] c):根据字符串数组的内容，来创建字符串对象
        char[] chars={'a','b','c'};
        String s3=new String(chars);
        System.out.println(s3);
        //4.public String(byte[] b):根据字节数组的内容，求创建字符串对象
        byte[] bytes={97,98,99,65,66,67};
        String s4=new String(bytes);
        System.out.println(s4);
        System.out.println("-------------------");
    }
}
有什么区别吗?面试常考

以""方式给出的字符串对象，在字符串常量池中存储，而且相同内容只会在其中存储一份

通过构造器new对象，每new一次都会产生一个新对象，放在堆内存中

String s1="abc";

String s2="abc";

System.out.println(s1==s2);

char[] chs={'a','b','c'};

String s3==new String(chs);

String s4=new String(chs);

System.out.println(s3==s4);

 String常见面试题:

反编译:将想要查看的代码路径拷贝出来，在'我的电脑'中找出来，然后将其拖到idea中可以查看编译后的代码

String类常用API-字符串内容比较:

package string;

import java.util.Scanner;

public class StringEqualsDemo3 {
    public static void main(String[] args) {
        //1.正确登录名和密码
        String okName="itheima";
        String okPassWord="123456";
        //2.请您输入登录名称和密码
        Scanner sc = new Scanner(System.in);
        System.out.println("登陆名称:");
        String name=sc.next();
        System.out.println("登录密码:");
        String passWord=sc.next();
        //3.判断用户输入的登录名称和密码与正确的内容是否相等
        if(okName==name&&okPassWord==passWord){
            System.out.println("登陆成功!");
        }else{
            System.out.println("用户名或者密码错误了!");
        }
        if(okName.equals(name)&&okPassWord.equals(passWord)){
            System.out.println("登陆成功");
        }else{
            System.out.println("用户名或者密码错误了");
        }

//4.忽略大小写比较内容的Api:一般用于比较验证码这样的业务逻辑
String sysCode="23AdFh";
String code1="23aDfH";
System.out.println(sysCode.equals(code1));
System.out.println(sysCode.equalsIgnoreCase(code1));
    }
}

1.如果是字符串比较应该使用什么方式进行比较,为什么?

使用String提供的equlas方法

只关心内容一样就返回true

2.开发中什么时候使用==比较数据

基本数据类型比较时使用

package string;

public class StringAPIOtherDemo4 {
    public static void main(String[] args) {
        //1.public int length():获取字符串的长度
        String name="我爱你中国love";
        System.out.println(name.length());
        //2.public char charAt(int index):获取某个索引位置处的字符
        char c=name.charAt(1);
        System.out.println(c);
        System.out.println("-----遍历字符串中的每个数组------");
        for (int i = 0; i < name.length(); i++) {
            char ch=name.charAt(i);
            System.out.println(ch);
        }
        //3.public char[] toCharArray():把字符串转换成字符数组
        char[] chars=name.toCharArray();
        for (int i = 0; i < chars.length; i++) {
            char ch=chars[i];
            System.out.println(ch);
        }
        //4.public String substring(int beginIndex,int endIndex):包前不包后
        String name2="Java是最好的编程语言";
        String rs=name2.substring(0,9);
        String rs1=name2.substring(4,9);
        System.out.println(rs1);
        //5.public String substring(int beginIndex):从当前索引一直获取到末尾
        String rs2=name2.substring(4);
        System.out.println(rs2);
        //6.public String replace(CharSequence target,CharSequence replacement)
        //替换关键字
        String name3="耿巧云我爱你!永远都爱你";
        String rs3=name3.replace("耿巧云","***");
        System.out.println(rs3);
        //7.public boolean contains(CharSequence s)是否包含
        System.out.println(name3.contains("耿巧云"));//true
        System.out.println(name3.contains("你好"));//false
        //8.public boolean startsWiths(String prefix)判断是否是最开始的
        System.out.println(name3.startsWith("耿巧云"));//true
        System.out.println(name3.startsWith("耿巧云我"));//true
        System.out.println(name3.startsWith("耿巧云1"));//false
        //9.public String[] split(String s):按照某个内容吧字符串分割成字符串数组返回
        String name4="王宝强,贾乃亮,陈羽凡";
        String[] names=name4.split(",");
        for (int i = 0; i < names.length; i++) {
            System.out.println("选择了:"+names[i]);
        }
    }
}

练习题:

package string;

import java.nio.charset.StandardCharsets;
import java.util.Random;

/**
 *练习题:使用String完成随机成5位的验证码 
 */
public class StringEcec1 {
    public static void main(String[] args) {
        //1.定义可能出现的字符信息
        String datas="absyhhiTGSTHWRQWr4234545STHWRisvgouygtopo";
        //2.循环5次，每次生成一个随机的索引，提取对应的字符链接起来即可
        String code="";
        Random r=new Random();
        for (int i = 0; i < 5; i++) {
            //随机生成一个索引
            int index=r.nextInt(datas.length());
            char c=datas.charAt(index);
            code+=c;
        }
        //3.输出字符串变量即可
        System.out.println(code);
    }
}

package string;
import java.util.Scanner;
/**
 * 手机号码屏蔽
 */
public class StringEcec3 {
    public static void main(String[] args) {
        //1.键盘录入一个手机号码
        Scanner sc=new Scanner(System.in);
        System.out.println("请输入您的手机号码");
        String tel=sc.next();
        //2.截取号码的前三位，后四位
        String before=tel.substring(0,3);
        String after=tel.substring(7);
        String s=before+"****"+after;
        System.out.println(s);
    }
}

集合概述:

集合与数组类似，也是一种容器，用于装数据的

数组的特点:

数组定义完成并启动后,类型确定、长度固定

集合的大小不固定，启动后可以动态变化，类型也可以选择不固定

集合非常适合做元素个数不固定，且要进行增删操作的业务场景

集合提供了许多丰富、好用的功能，而数组的功能很单一

总结:

数组和集合的元素存储的个数问题?

数组定义后类型确定，长度固定

集合类型可以不固定，大小是可变的

数组和集合适合的场景?

数组适合做数据个数和类型确定的场景

集合适合做数据个数不确定，且要做增删元素的场景

ArrayList集合:

ArrayList是集合中的一种，它支持索引

Arraylist集合的对象获取

public ArrayList()      创建一个空的集合对象

ArrayList集合添加元素的方法

public boolean add(E e)   将指定的元素追加到此集合的末尾

public void add(int index, E element)在此集合中的指定位置插入指定的元素

package com.itheima.arrayList;

import java.util.ArrayList;

/*目标:创建ArrayList对象，代表集合容器，往里面添加元素
*/
public class ArrayListDemo1 {
    public static void main(String[] args) {
        //1.创建ArrayList集合的对象
        ArrayList list=new ArrayList();
        //2.添加数据
        list.add("Java");
        list.add("Java");
        list.add('你');
        list.add(23);
        list.add(24.6);
        list.add(false);
        System.out.println(list.add('中'));
        System.out.println(list);
        //给指定索引插入元素
        list.add(1,"赵敏");
        System.out.println(list);
    }
}

ArrayList类如何创建集合对象的，如何添加元素

ArrayList list=new ArrayList();

list.add( "数据");

list.add("1","数据");

泛型概述：

ArrayList<E>:其实就是一个泛型类，可以在编译阶段约束集合对象只能操作某种数据类型

举例:

ArrayList<String>:此集合只能操作字符串类型的元素

ArrayList<Integer>:此集合只能操作整数类型的元素

注意:集合中只能存储引用类型，不支持基本数据类型

package com.itheima.arrayList;
import java.util.ArrayList;
public class ArrayListDemo2 {
    public static void main(String[] args) {
        ArrayList<String> list=new ArrayList<>();//JDK1.7开始，泛型后面的类型申明可以不屑
        list.add("Java");
        list.add("MySql");
        ArrayList<Integer> list1=new ArrayList<>();
        list1.add(23);
        list1.add(43);
        ArrayList<Object> list2=new ArrayList<>();
        list.add("Java");
    }
}

怎么去统一ArrayList集合操作的元素类型?

使用泛型:<数据类型>

ArrayList<String> list1=new ArrayList();

package com.itheima.arrayList;

import java.util.ArrayList;

public class ArrayListDemo3 {
    public static void main(String[] args) {
        ArrayList<String> list= new ArrayList<>();
        list.add("Java");
        list.add("MySql");
        list.add("MyBatis");
        //1.public E get(int index):获取某个索引位置处的元素值
        String e=list.get(2);
        System.out.println(e);
        //2.public int size():获取集合的大小(元素个数)
        System.out.println(list.size());
        //3.完成集合的遍历
        for (int i = 0; i < list.size(); i++) {
            System.out.println(list.get(i));
        }
        //4.public E remove(int index):删除某个索引位置处的元素值，并返回被删除的元素值
        System.out.println(list);
        String e2=list.remove(2);
        System.out.println(e2);
        //5.public boolean remove(Object o):直接删除元素值，删除成功返回true,删除失败返回false
        System.out.println(list.remove("Java"));
        System.out.println(list);
        ArrayList<String> list1=new ArrayList<>();
        list1.add("Java");
        list1.add("王宝强");
        list1.add("Java");
        list1.add("MySql");
        System.out.println(list1);
        //只会删除第一次出现的元素值，后面的不删除
        System.out.println(list1.remove("Java"));
        System.out.println(list1);
        //6.public E set(int index,E element):修改某个索引位置处的元素值
        String e3= list1.set(0,"贾乃亮");
        System.out.println(e3);
        System.out.println(list1);
    }
}

package com.itheima.arrayList;
import java.util.ArrayList;
/**
 案例:从集合中遍历元素且删除
 * */
public class ArrayListDemo4 {
    public static void main(String[] args) {
        //1.创建集合对象，存入学生成绩(98,77,66,89,79)
        ArrayList<Integer> scores=new ArrayList<>();
        scores.add(98);
        scores.add(78);
        scores.add(36);
        scores.add(70);
        scores.add(17);
        scores.add(100);
        System.out.println(scores);
/*        //1.遍历集合中的每个元素
        for (int i = 0; i < scores.size(); i++) {
            int s=scores.get(i);
            //2.判断这个分数是否低于80分，如果低于则从集合中删除它
            if(s<80){
                scores.remove(i);
            }
        }*/
       // System.out.println(scores);98，36，17，100
       //这样会出现一个经典的bug, 当删除掉上一个元素时，下标跑去了下一个元素，所以会造成跳格删除的现象
        for (int i = scores.size()-1; i > 0; i--) {
            int score=scores.get(i);
            //2.判断这个分数是否低于80分，如果低于则从集合中删除它
            if(score<80){
                scores.remove(i);
            }
        }
        System.out.println(scores);
    }
}

从集合中遍历元素，并筛选出元素遍历它，应该怎么做?

从集合后面遍历然后删除，可以避免漏掉元素

package com.itheima.arrayList;
import java.util.ArrayList;
/**
  案例:集合存储自定义元素并遍历
 */
public class ArrayListTest1 {
    public static void main(String[] args) {
        //1.定义一个电影类,movie

        //2.定义一个ArrayList集合存储影片对象
        ArrayList<Movie> movies=new ArrayList<>();
        //3.创建影片对象封装电影数据，把对象加入到集合中去
        //Movie m1=new Movie("<肖申克的救赎>",9.7,"罗宾斯");
        //movies.add(m1);
        movies.add(new Movie("<肖申克的救赎>",9.7,"罗宾斯"));
        movies.add(new Movie("<霸王别姬>",9.6,"张国荣"));
        movies.add(new Movie("<阿甘正传>",8.9,"汤姆"));
        //System.out.println(movies);此时打印的是地址，所以需要遍历
        //4.遍历集合中的影片并展示出来
        for (int i = 0; i < movies.size(); i++) {
            Movie movie= movies.get(i);
            System.out.println("片名:"+movie.getName());
            System.out.println("评分:"+movie.getScore());
            System.out.println("主演:"+movie.getActor());
        }
    }
}


package com.itheima.arrayList;
import java.util.ArrayList;
/**
 案例:从集合中遍历元素且删除
 * */
public class ArrayListDemo4 {
    public static void main(String[] args) {
        //1.创建集合对象，存入学生成绩(98,77,66,89,79)
        ArrayList<Integer> scores=new ArrayList<>();
        scores.add(98);
        scores.add(78);
        scores.add(36);
        scores.add(70);
        scores.add(17);
        scores.add(100);
        System.out.println(scores);
/*        //1.遍历集合中的每个元素
        for (int i = 0; i < scores.size(); i++) {
            int s=scores.get(i);
            //2.判断这个分数是否低于80分，如果低于则从集合中删除它
            if(s<80){
                scores.remove(i);
            }
        }*/
       // System.out.println(scores);98，36，17，100
       //这样会出现一个经典的bug, 当删除掉上一个元素时，下标跑去了下一个元素，所以会造成跳格删除的现象
        for (int i = scores.size()-1; i > 0; i--) {
            int score=scores.get(i);
            //2.判断这个分数是否低于80分，如果低于则从集合中删除它
            if(score<80){
                scores.remove(i);
            }
        }
        System.out.println(scores);
    }
}

 

package com.itheima.arrayList;
import java.util.ArrayList;
/**
  案例:集合存储自定义元素并遍历
 */
public class ArrayListTest1 {
    public static void main(String[] args) {
        //1.定义一个电影类,movie

        //2.定义一个ArrayList集合存储影片对象
        ArrayList<Movie> movies=new ArrayList<>();
        //3.创建影片对象封装电影数据，把对象加入到集合中去
        //Movie m1=new Movie("<肖申克的救赎>",9.7,"罗宾斯");
        //movies.add(m1);
        movies.add(new Movie("<肖申克的救赎>",9.7,"罗宾斯"));
        movies.add(new Movie("<霸王别姬>",9.6,"张国荣"));
        movies.add(new Movie("<阿甘正传>",8.9,"汤姆"));
        //System.out.println(movies);此时打印的是地址，所以需要遍历
        //4.遍历集合中的影片并展示出来
        for (int i = 0; i < movies.size(); i++) {
            Movie movie= movies.get(i);
            System.out.println("片名:"+movie.getName());
            System.out.println("评分:"+movie.getScore());
            System.out.println("主演:"+movie.getActor());
        }
    }
}

 元素搜索:

package com.itheima.arrayList;

public class Student {
    private String studyId;
    private String name;
    private int age;
    private String className;

    public Student() {
    }

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

    public String getStudyId() {
        return studyId;
    }

    public void setStudyId(String studyId) {
        this.studyId = studyId;
    }

    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 String getClassName() {
        return className;
    }

    public void setClassName(String className) {
        this.className = className;
    }
}


package com.itheima.arrayList;

import java.util.ArrayList;
import java.util.Scanner;

/**
 学生信息系统:展示数据，并按照学号完成搜索
 */
public class ArrayListTest2 {
    public static void main(String[] args) {
        //1.定义一个学生类，后期用于创建对象封装到学生数据
        //2.定义以恶集合对象用于装学生对象
        ArrayList<Student> students = new ArrayList<>();
        students.add(new Student("20190708", "叶孤城", 24, "护理一班"));
        students.add(new Student("20180303", "东方不败", 23, "推拿二班"));
        students.add(new Student("20190705", "西门吹雪", 27, "神经病一科"));
        students.add(new Student("20200803", "梅超峰", 32, "中医学四班"));
        System.out.println("学号\t\t名称\t\t年龄\t\t班级");
        //3.遍历集合中的每个学生对象并展示其数据
        for (int i = 0; i < students.size(); i++) {
            Student s = students.get(i);
            System.out.println(s.getStudyId() + "\t\t" + s.getClassName() + "\t\t" +
                    s.getName() + "\t\t" + s.getAge());
        }
        //4.让用户不断的输入学号、可以搜索出该学生对象信息并展示出来(独立成方法)
        Scanner sc = new Scanner(System.in);
        while (true) {
            System.out.println("请您输入要查询的学生学号:");
            String id = sc.next();
            Student s = getStudentByStudyId(students, id);
            //判断学号是否存在
            if (s == null) {
                System.out.println("查无此人");
            } else {
                System.out.println(s.getStudyId() + "\t\t" + s.getClassName() + "\t\t" +
                        s.getName() + "\t\t" + s.getAge());
            }
        }
    }
    /**
     * 根据学号，去集合中
     * @param students
     * @param studyId
     * @return
     */
    public static Student getStudentByStudyId(ArrayList<Student> students,String studyId){
        for (int i = 0; i < students.size(); i++) {
            Student s = students.get(i);
            if(s.getStudyId().equals(studyId)){
                return s;
            }
        }
        return null;
    }
}
举报

相关推荐

Java学习-第21天

java开发语言

学习java第14天

eclipse

学习Java第16天

java-ee

学习Java第14天

java

java学习第7天

java学习开发语言

学习java第12天

java

云原生学习笔记 - 第8天

PodYAML配置文件云原生云计算

JAVA第15天学习笔记

Java泛型自定义异常后端开发

黑马第8天

htmlcss3

Java基础学习第4天

java
0 条评论