一知识总结
String字符串(重点)
//这句话执行时,创建一个"Tom"字符串对象,将其地址保存在变量name中
String name = "Tom";
//这句话执行看似在改变字符串的值,实际是创建了一个新的"Jerry"字符串对象,将其地址保存到变量
name中
name = "Jerry";
//以上两句,在内存中,会有两个字符串对象"Tom"和"Jerry",没有任何字符串发生了改变,只是name引用
了不同的字符串地址
//字符串可以当做数组使用
String str1 = "hello";
//字符串对象实际是一个字符数组对象"包装"而来
char[] list = {'h', 'e', 'l', 'l', 'o'};
String str2=new String(list);
System.out.println(str1);
System.out.println(str2);
String类使用时注意
如何创建字符串对象
1.使用""赋值创建
String str="abc";
2.通过构造方法创建
常用构造方法说明
string(0
创建一个空白字符串对象。
String(String str)
创建一个指定字符串的字符串对象。
不同方式创建字符串的过程
使用""赋值的形式创建
//这句话执行时,先判断字符串常量池(缓冲区)中是否存在"ab",不存在则创建,将其地址保存到str1变量
中
String str1 = "ab";
//这句话执行时,先判断字符串常量池(缓冲区)中是否存在"ab",已存在,不用创建,将其地址保存到str2
变量中
String str2 = "ab";
//这句话执行时,+两端如果都是""定义的字符串,拼接后再判断字符串常量池(缓冲区)中是否存在
//拼接后的"ab"依然存在,将其地址保存到str3变量中
String str3 = "a" + "b";
//以上三句话,只会在内存中的字符串常量池(缓冲区)创建一个字符串对象"ab",分别引用给3个变量
System.out.println(str1==str2);//true
System.out.println(str1==str3);//
使用构造方法String(String str)创建
//这句话执行时的流程
//1.在字符串常量池中寻找"ab",不存在,创建
//2.在堆中new String(),将字符串常量池中的"ab"保存到new出来的区域
//3.将堆中new出来的地址保存到栈中变量str1中
String str1 = new String("ab");
//这句话执行时的流程
//1.在字符串常量池中寻找"ab",存在,直接引用
//2.在堆中new String(),将字符串常量池中的"ab"保存到new出来的区域
//3.将堆中new出来的地址保存到栈中变量str2中
String str2 = new String("ab");
//由于str1和str2是堆中的两个区域,所以结果为false
System.out.println(str1 == str2);//false
下面的是易错点 对于我来说
使用+拼接""和new出来的字符串对象创建
//在字符串常量池中创建"ab"
String str1 = "ab";
//1.创建StringBuilder对象
//2.在字符串常量池中创建"a"
//3.在字符串常量池中创建"b"
//4.创建String对象
//5.调用StringBuilder的append方法,将"a"和new String("b")拼接
String str2 = "a" + new String("b");//一共创建了"a","b",String,StringBuilder这四个对
象
//两个不同的地址
System.out.println(str1==str2);//false
字符串相关面试题
//题目一
String str1 = "ab";//常量池中创建"ab"
String str2 = new String("ab");//堆中new String()保存常量池中已有的"ab"
String str3 = "a" + "b";//用常量池已有的"ab"
String str4 = "a" + new String("b");//常量池中创建"a"和"b",堆中new String()和new
StringBuilder()
String str5 = "ab";//用常量池已有的"ab"
System.out.println(str1 == str2);//false
System.out.println(str1 == str3);//true
System.out.println(str1 == str4);//false
System.out.println(str1 == str5);//true
//题目二
//这两句话执行后,会创建几个对象
String s1 = "abc";
String s2 = "a" + "b" + "c";
//在字符串常量池中创建一个对象"abc"
//题目三
//这两句话执行后,会创建几个对象
String s3 = new String("你好");//常量池:"你好",堆中:new String()
String s4 = new String("你好");//堆中:new String()
//3个对象:堆中两个new String(),常量池中"你好"
//题目四
//这两句话执行后,会创建几个对象
String s5 = "hello";//常量池:"hello"
String s6 = "hel" + new String("lo");//常量池:"hel"和"lo" 堆:new String()和new
StringBuilder
//5个对象:常量池:"hello"、"hel"和"lo",堆:new String()和new StringBuilder
//题目五
String s7 = new String("wor");//常量池:"wor",堆:new String()
String s8 = s7 + "ld";//常量池:"ld" 堆:new StringBuilder()
//4个对象:常量池:”wor"和"ld",堆:new String()和new StringBuilder
字符串String类中的常用方法
public class Homework {
public static void main(String[] args) {
String idCard = "500123199903262154";
//使用substring截取所需信息
String birthYear = idCard.substring(6, 10);
String sexNum = idCard.substring(16, 17);
//字符串转换为数字Integer.parseInt(String str)
int age = 2022 - Integer.parseInt(birthYear);
if (Integer.parseInt(sexNum) % 2 == 0) {
System.out.println(age + "岁,性别女");
} else {
System.out.println(age + "岁,性别男");
}
System.out.println("=====================");
String phone = "13915811581";
//如果使用replace,会全部替换
String newPhone = phone.replaceFirst(phone.substring(3, 7), "****");
System.out.println(newPhone);
System.out.println("=====================");
String str = "how are you";
//将原字符串转换为字符数组
char[] chars = str.toCharArray();
//定义翻转后的字符数组
char[] reverseChars = new char[str.length()];
//倒序遍历
for (int i = chars.length - 1; i >= 0; i--) {
//正向存储
reverseChars[chars.length - i - 1] = chars[i];
}
//使用字符串的构造方法,将数组定义为字符串
String reverseStr = new String(reverseChars);
System.out.println(reverseStr);
System.out.println("=====================");
String url = "www.baidu.edu";
//从.最后一次出现的位置开始截取至末尾
String test = url.substring(url.lastIndexOf("."));
switch (test) {
case ".com":
System.out.println(url+"是一个商业网站");
break;
case ".edu":
System.out.println(url+"是一个教育网站");
break;
case ".gov":
System.out.println(url+"是一个政务网站");
break;
case ".org":
System.out.println(url+"是一个非盈利网站");
break;
default:
System.out.println("无法识别");
break;
}
}
}
StringBuilder类
StringBuffer类
构造方法
System类
Date类
在实际应用中时不时是会用到这个类
构造方法
SimpleDateFormat类
这个类会经常和Ddate类一起使用
Calendar类
日历类
//获取Calendar类的对象
Calendar cal = Calendar.getInstance();
会用这个类就行
包装类
这个就会与实际发生作用
在实际工作中对数据的转换
//自动装箱
Integer anInt = 345;
//自动拆箱
int i = anInt;
异常(不重要)
会抛异常就行
处理异常
try{
//可能出现异常的代码
}catch(异常类 异常对象){
//如果出现异常对象,且与catch小括号中的异常类型匹配,就会执行这里的代码
}catch(异常类 异常对象){
//如果出现异常对象,且与catch小括号中的异常类型匹配,就会执行这里的代码
}finally{
//无论程序是否会抛出异常,都要执行的代码
}
public class Test{
public void fun() throws InterruptException{//这时该方法就会有一个声明:该方法可能
会抛出异常
//这句话直接写完后,会报错,因为sleep()方法可能会抛出InterruptException异常,属于
编译时异常,必须要处理
Thread.sleep(500);
}
}
throw和throws
public void fun() throws InterruptException{
Thread.sleep(500);
}
public void fun2(){
for(int i=0;i<10;i++){
if(i==5){
//手动抛出异常
throw new NullPointerException();
}
}
}
集合框架(集合家族)重点
Collection接口
ArrayList实现类(掌握)
ArrayList和LinkedList的区别(要记得)
遍历方式
System.out.println("使用普通for循环遍历");
//方式一:普通for循环
for (int i = 0; i < nameList.size(); i++) {//从0遍历到size()
String name = nameList.get(i);//通过get(int index)获取指定索引的元素
System.out.println(name);
}
System.out.println("使用增强for循环遍历");
//方式二:增强for循环
for (String name : nameList) {
System.out.println(name);
}
System.out.println("使用迭代器遍历");
//方式三:迭代器
//Collection类型的集合对象.iterator(),获取迭代器
Iterator<String> iterator = nameList.iterator();
// iterator.hasNext()判断集合中是否还有下一个元素
// iterator.next();获取下一个元素
while (iterator.hasNext()) {
String name = iterator.next();
System.out.println(name);
}
方法
文件类File
常用方法
递归遍历文件夹
import java.io.File;
import java.util.Date;
public class Test3 {
//查看某个目录下的所有文件
public static void main(String[] args) {
File source = new File("E:\\adobe");
Test3 t = new Test3();
t.fun(source);
}
/*
* 递归遍历文件夹
* */
public void fun(File source) {
//输出某个目录中超过3个月未使用且大于500MB的文件
/*
long start = source.lastModified();
long end = System.currentTimeMillis();
if ((end - start) / 1000 / 3600 / 24 > 90 && source.length() / 1024 /
1024 > 500) {
System.out.println(source.getName() + "\t" + new
Date(source.lastModified()) + "\t" + source.length() / 1024 / 1024);
}*/
//判断是否为目录
if (source.isDirectory()) {
//将其展开
for (File child : source.listFiles()) {
//因为子文件有可能是目录,继续调用本方法
fun(child);
}
}
}
}
IO
FileInputStream文件字节输入流(掌握)
常用方法
FileOutputStream文件字节输出流(掌握)
常用方法
BufferedReader缓冲字符输入流(掌握)
常用方法
BufferedWriter缓冲字符输出流(掌握)
常用方法
ObjectOutputStream对象字节输出流(序列
化)(掌握)
ObjectInputStream对象字节输入流(反序列
化)(掌握)
网络编程
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.net.InetAddress;
import java.net.ServerSocket;
import java.net.Socket;
import java.net.UnknownHostException;
/*
* 使用套接字对象,实现客户端向服务端发送文件
*
* 定义服务端套接字对象
客户端
* */
public class Server {
public static void main(String[] args) throws IOException {
//以本机创建服务端套接字对象
ServerSocket server = new ServerSocket(8899, 100,
InetAddress.getLocalHost());
//等待客户端连接,返回连接的客户端套接字对象
Socket client = server.accept();
//定义要将读取到的数据写入到本地的文件字节输出流对象
FileOutputStream fos = new FileOutputStream("上传文件.md");
//获取客户端与服务端的输入流对象,读取发送的数据
InputStream is = client.getInputStream();
//定义读取的字节数组
byte[] bytes = new byte[1024 * 1024 * 8];
int count = is.read(bytes);
while (count != -1) {
//将读取到的数据写入到本地
fos.write(bytes, 0, count);
count = is.read(bytes);
}
fos.close();
is.close();
}
}
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.OutputStream;
import java.net.Socket;
/*
* 定义客户端套接字对象
* */
public class Client {
public static void main(String[] args) throws IOException {
//创建客户端套接字对象,连接指定的服务端套接字对象
Socket client = new Socket("192.168.31.39", 8899);
//获取客户端与服务端的输出流对象
OutputStream os = client.getOutputStream();
//成功连接后,将某个文件发送给服务端
//定义要发送的文件对象
File file = new File("F:\\221001\\笔记\\面向对象部分回顾.md");
//读取要发送的文件
FileInputStream fis = new FileInputStream(file);
作业
//定义字节数组
byte[] bytes = new byte[1024 * 1024 * 8];
//循环读取要发送的文件
int count = fis.read(bytes);
while (count != -1) {
//将读取到的数据写入到客户端套接字与服务端套接字的通道中
os.write(bytes,0,count);
count = fis.read(bytes);
}
fis.close();
os.close();
}
}
二我认为的重要知识点及我的错题
在这个阶段的学习中,知识多.所以我要分出重要知识点,String类和集合类,还有就是File类,绝对是必须掌握的.其他知识我们必须会用,知道哪些方法怎样用
- 指出下列程序运行的结果 ( )
public class Example{
String str=new String("good");
char[] ch = {'a','b','c'};
public static void main(String args[]){
Example ex=new Example();
ex.change(ex.str,ex.ch);
System.out.print(ex.str+" and ");
Sytem.out.print(ex.ch);
}
public void change(String str,char ch[]){
str="test ok";
ch[0]='g';
}
}
[A] good and abc [B] good and gbc
[C] test ok and abc [D] test ok and gbc
2.在读文件Employee.dat时,最好使用的类是()。
A.BufferedReader
B.DataInputStream
C.DataOutputStream
D.FileInputStream
3.以下Java语句中,
String str = “123456789”;
str =str.subString(1,3);
执行后str中的值为( )
(A) “23” (B) “123”
(C) “12” (D) “234”
4. 在Java语言中,下面代码编译运行结果是( )。(选择一项)
publicclass A {
public void changeName(StringBuffer name, StringBuffer nickname) {
name = new StringBuffer("YangFan");// 第三行代码
nickname.append("1");
System.out.print(name);
System.out.print(" " + nickname);
}
Public static void main(String[] args) {
StringBuffer name = new StringBuffer("YangYang");
StringBuffer nickname = new StringBuffer("Yaya");
A a = newA();
a.changeName(name, nickname);
System.out.print(" " + name);
System.out.print(" " + nickname);
}
}
A.输出:YangFan Yaya1 YangYang Yaya
B.输出:YangFan Yaya1 YangYang Yaya1
C.因为第三行代码有错误,程序无法编译通过
D.输出:YangFan Yaya1 YangFan Yaya1
三分享homework
import java.io.*;
import java.util.ArrayList;
import java.util.Scanner;
public class Main {
public static void main(String[] args) throws IOException, ClassNotFoundException {
StudentManager sm = new StudentManager();
ArrayList<Student> studentList = null;
while (true) {
System.out.println("1.初始化数据");
System.out.println("2.加载查看信息");
Scanner sc = new Scanner(System.in);
switch (sc.nextInt()) {
case 1:
File source = new File("f:/作业素材");
sm.init(source);
//对该集合进行序列化
studentList = sm.getStudentList();
ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("f:/stuList.stu"));
oos.writeObject(studentList);
oos.close();
System.out.println("数据加载成功");
break;
case 2:
File file = new File("f:/stuList.stu");
if (!file.exists()) {
System.out.println("数据未初始化");
return;
}
//反序列化
ObjectInputStream ois = new ObjectInputStream(new FileInputStream(file));
studentList = (ArrayList<Student>) ois.readObject();
ois.close();
for (Student student : studentList) {
System.out.println(student);
}
break;
}
}
}
}
mport java.io.Serializable;
/*
* 要对该类进行序列化,必须先实现Serializable接口
* */
public class Student implements Serializable {
private String stuNo;
private String stuName;
@Override
public String toString() {
return "Student{" +
"stuNo='" + stuNo + '\'' +
", stuName='" + stuName + '\'' +
'}';
}
public Student(String stuNo, String stuName) {
this.stuNo = stuNo;
this.stuName = stuName;
}
public String getStuNo() {
return stuNo;
}
public void setStuNo(String stuNo) {
this.stuNo = stuNo;
}
public String getStuName() {
return stuName;
}
public void setStuName(String stuName) {
this.stuName = stuName;
}
}
import java.io.File;
import java.util.ArrayList;
public class StudentManager {
//定义保存每个文件名的集合
private ArrayList<String> fileNameList = new ArrayList<>();
//定义保存学生对象的集合
private ArrayList<Student> studentList = new ArrayList();
/*
* 只能获取学生集合
* */
public ArrayList<Student> getStudentList() {
return studentList;
}
/*
* 初始化数据
* 读取提供的文件夹,获取其中的文件名,截取相关信息
* */
public void init(File file) {
//调用递归读取文件的方法
getFileName(file);
//遍历文件名的集合
for (String fileName : fileNameList) {
//使用.分割
String s = fileName.split("\\.")[0];
//使用空格分割
String stuNo = s.split(" ")[0];
String stuName = s.split(" ")[1];
//创建学生对象,添加到集合中
Student student = new Student(stuNo, stuName);
studentList.add(student);
}
}
/*
* 递归遍历文件
* */
public void getFileName(File file) {
if (file.isFile()) {
//将文件名保存到集合中
fileNameList.add(file.getName());
} else {
for (File listFile : file.listFiles()) {
getFileName(listFile);
}
}
}
}