文章目录
- 1.结果转换为byte类型
- 2.三元表达式
- 3.Scanner控制台输入
- 4.JDBC数据库操作
- 5.if语句结构
- 6.switch语句结构
- 7.星期枚举类
- 8.循环
- 9. Random随机类
- 10.数组
- 11.抽象类
- 12.接口
- 13.字符集进行编码，解码
- 14.创建object类
- 15.String类
- 15.1字节数组里面的整数转换成字母
- 15.2将单个字母拼接成单词
- 15.3比较两个字符串是否相等，区分大小写
- 15.4不区分大小写比较两个字符串是否相等
- 15.5判断字符串是不是从字符a开头的
- 15.6判断字符串是不是以字符c结尾的
- 15.7判断字符串对象s2是不是空字符串
- 15.8判断字符串对象s2的长度
- 15.9获取字符串对象s2索引1位置的字符
- 15.9获取字符串对象s2字符c所在位子的索引
- 15.10获取字符串对象s4字符b最后出现所在位子的索引
- 15.11截取字符串对象s4字符从索引2开始以后的所有字符
- 15.12截取字符串对象s4字符从索引2开始4结束，不包含4的所有字符
- 15.13将字符串对象s2（“abc”）转换成字节数组
- 15.14将字符串对象s2（“abc”）转换成字符数组
- 15.15将指定类型的数据转换成字符串类型数据
- 15.16将字符串对象s2("abc")的字符b替换为d
- 15.17将字符串对象s2("abc")以空格进行切割，返回切割后的字符串数据，原字符串不受影响
- 15.17去除字符串sb对象两边的空格
- 16.容器
- 17.日期类
- 18.Math类
- 19.类型转换
- 20.集合
- 21.try catch
- 22.IO流
- 22.1创建IO流对象
- 22.2创建1.txt文件
- 22.3创建单级文件夹
- 22.4创建多级文件夹
- 22.5获取绝对路劲
- 22.6获取相对路劲
- 22.6获取文件名
- 22.7获取所有文件夹名称
- 22.8获取所有文件夹和文件的名称
- 22.9文件复制拷贝
- 22.10所有目录和文件（包括多级目录),复制
- 22.11遍历目录并将所有文件的绝对路劲输出到控制台，多层级文件夹里面的文件路径也可以输出
- 22.12读取一个字符
- 22.13连续读取所有字符
- 22.14创建字符输出流对象,一次写一个字
- 22.15创建字符输出流对象,一次写入一个指定的字符数组
- 22.16文件复制1.txt的内容写符到2.txt文件里面（字节流拷贝）
- 22.17文件复制1.txt的内容写符到2.txt文件里面,按字符数组拷贝
- 22.18字符缓冲流，文件复制1.txt的内容写符到2.txt文件里面
- 22.19字符缓冲流，文件复制1.txt的内容写符到2.txt文件里面，一行一行读取
- 22.20字节流是针对图片等其他文件类型的
- 22.21 编码方式IO流
- 22.22 将ArrayList集合里面的内容IO流写入文件
- 22.23 字节打印流：往文件里my.txt里面写入
- 23.反射
- 24.创建泛型类，泛型接口
- 25.类型通配符
- 26.创建参数可变函数
- 27.序列化和反序列化
- 28网络通信
- 29.定义接口并且实现接口
- 30.通过idea软件运行gitte上面的项目
- 31.maven和git的使用
1.结果转换为byte类型
//1.将aa+dd的输出结果转换为byte类型
byte dd = (byte) (aa+dd);
2.三元表达式
//2.三元表达式
int max = (a>=b)?a:b;
3.Scanner控制台输入
//3.Scanner控制台输入
//创建键盘录入对象
Scanner sc = new Scanner(System.in);
System.out.println("请输入一个整数：");
//接收数据
int i = sc.nextInt();
//把数据输出
System.out.println("i:"+i);
/**
4.hasNextXXX是返回一个布尔值，是否还有下一个输入项，XXX是可以任意类型的
nextXXX 获取下一个输入项，可以是任意XXX类型
String nextLine() 换行符分隔
String next() 空格，tab,回车等作为分隔符，后面的内容不显示了，只显示前面的内容
nextInt接受整数,nextLine接受字符串 这两个用的最多
*/
Scanner sc = new Scanner(System.in);
System.out.println("请输入一个整数：");
if(sc.hasNextInt()){ //判断下一个输入的是否是整数
int num = sc.nextInt();
System.out.println(num);
}
3.1连着Scanner输入5个学生的姓名，语文成绩，数学成绩，英语成绩
//5.连着输入5个学生的姓名，语文成绩，数学成绩，英语成绩
public void test8(){
for (int i = 0; i < 5; i++) {
Scanner sc = new Scanner(System.in);
System.out.println("请输入第" + (i + 1) + "个学生信息：");
System.out.println("姓名：");
String name = sc.nextLine();
System.out.println("语文成绩：");
int chinese = sc.nextInt();
System.out.println("数学成绩：");
int math = sc.nextInt();
System.out.println("英语成绩：");
int english = sc.nextInt();
}
4.JDBC数据库操作
4.1JDBC导入驱动包
//jdbc
//1.导入驱动包
//1.update account set balance = 500 where id = 1
@Test
public void test() throws Exception {
/**
* 1.DriverManager:驱动管理对象
* 2.Connection:数据库连接对象
* 3.Statement：执行sql对象
* 4.ResultSet:结果集对象
* 5.PreparedStatement:执行sql对象
*/
//1.导包
//2.注册驱动(mysql5以后，可以省略这一步)
Class.forName("com.mysql.jdbc.Driver");
//3.获取数据库连接对象
//url: jdbc:mysql://ip地址：端口号/数据库名称 user:数据库用户名 password:数据库密码
Connection conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/test", "root", "12");
//4.定义Sql语句
String sql = "update account set balance = 500 where id = 1";
//5.获取执行Sql对象Statement
Statement stmt = conn.createStatement();
//6.执行sql语句,executeUpdate():执行增删改 executeQuery():执行select语句 execute：可以执行任意Sql语句
int count = stmt.executeUpdate(sql);
//7.处理结果
System.out.println(count);
//8.释放资源
stmt.close();
conn.close();
}
//2.insert into account values(5 ,'刘德华',15000)
@Test
public void test1() throws Exception {
/**
* 1.DriverManager:驱动管理对象
* 2.Connection:数据库连接对象
* 3.Statement：执行sql对象
* 4.ResultSet:结果集对象
* 5.PreparedStatement:执行sql对象
*/
Statement stmt = null;
Connection conn = null;
try {
//1.导包
//2.注册驱动(mysql5以后，可以省略这一步)
Class.forName("com.mysql.jdbc.Driver");
//3.获取数据库连接对象
//url: jdbc:mysql://ip地址：端口号/数据库名称 user:数据库用户名 password:数据库密码
conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/test", "root", "12");
//4.定义Sql语句
String sql = "insert into account values(5 ,'刘德华',15000)";
//5.获取执行Sql对象Statement
stmt = conn.createStatement();
//6.执行sql语句,executeUpdate():执行增删改 executeQuery():执行select语句 execute：可以执行任意Sql语句
int count = stmt.executeUpdate(sql);
//7.处理结果
if (count > 0) {
System.out.println("成功执行" + count + "行");
} else {
System.out.println("执行失败");
}
} catch (Exception e) {
e.printStackTrace();
} finally {
//释放资源，避免空指针异常
if (stmt != null) {
try {
//8.释放资源
stmt.close();
} catch (SQLException e) {
e.printStackTrace();
}
}
if (conn != null) {
try {
//8.释放资源
conn.close();
} catch (SQLException e) {
e.printStackTrace();
}
}
}
}
//3.select * from account
@Test
public void test2(){
Statement stmt = null;
Connection conn = null;
ResultSet rs = null;
try {
//1.导包
//2.注册驱动(mysql5以后，可以省略这一步)
Class.forName("com.mysql.jdbc.Driver");
//3.获取数据库连接对象
//url: jdbc:mysql://ip地址：端口号/数据库名称 user:数据库用户名 password:数据库密码
conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/test", "root", "12");
//4.定义Sql语句
String sql = "select * from account";
//5.获取执行Sql对象Statement
stmt = conn.createStatement();
//6.执行sql语句,executeUpdate():执行增删改 executeQuery():执行select语句 execute：可以执行任意Sql语句
rs = stmt.executeQuery(sql);
//7.处理结果
//7.1让游标向下移动一行
//rs.next();
//7.2获取数据
while(rs.next()) {
int id = rs.getInt(1); //获取第一列数据
String name = rs.getString("name"); //获取标签名为name的数据
double balance = rs.getDouble(3); //获取第三列数据
System.out.println(id + "--------------" + name + "--------------" + balance);
}
}catch (ClassNotFoundException e){
e.printStackTrace();
} catch (SQLException e) {
e.printStackTrace();
} finally {
//8.释放资源，避免空指针异常
if (rs != null) {
try {
//8.释放资源
rs.close();
} catch (SQLException e) {
e.printStackTrace();
}
}
if (stmt != null) {
try {
//8.释放资源
stmt.close();
} catch (SQLException e) {
e.printStackTrace();
}
}
if (conn != null) {
try {
//8.释放资源
conn.close();
} catch (SQLException e) {
e.printStackTrace();
}
}
}
}
//1.1 select * from emp，查询一个表的所有数据的方法封装，返回一个list集合
@Test
public List<Emp> findAll(){
Statement stmt = null;
Connection conn = null;
ResultSet rs = null;
List<Emp> list = null; //创建加载数据表字段对象的集合
try {
//1.导包
//2.注册驱动(mysql5以后，可以省略这一步)
Class.forName("com.mysql.jdbc.Driver");
//3.获取数据库连接对象
//url: jdbc:mysql://ip地址：端口号/数据库名称 user:数据库用户名 password:数据库密码
conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/test", "root", "12");
//4.定义Sql语句
String sql = "select * from emp";
//5.获取执行Sql对象Statement
stmt = conn.createStatement();
//6.执行sql语句,executeUpdate():执行增删改 executeQuery():执行select语句 execute：可以执行任意Sql语句
rs = stmt.executeQuery(sql);
//7.处理结果
//7.1获取数据
Emp emp = null;
list = new ArrayList<Emp>();
while(rs.next()) {
int id = rs.getInt("id");
String ename = rs.getString("ename");
int job_id = rs.getInt("job_id");
int mgr = rs.getInt("mgr");
Date joindate = rs.getDate("joindate");
Double salary = rs.getDouble("salary");
Double bonus = rs.getDouble("bonus");
int dept_id = rs.getInt("dept_id");
emp = new Emp();
emp.setId(id);
emp.setEname(ename);
emp.setJob_id(job_id);
emp.setMgr(mgr);
emp.setJoindate(joindate);
emp.setSalary(salary);
emp.setBonus(bonus);
emp.setDept_id(dept_id);
//装载集合
list.add(emp);
}
}catch (ClassNotFoundException e){
e.printStackTrace();
} catch (SQLException e) {
e.printStackTrace();
} finally {
//8.释放资源，避免空指针异常
if (rs != null) {
try {
//8.释放资源
rs.close();
} catch (SQLException e) {
e.printStackTrace();
}
}
if (stmt != null) {
try {
//8.释放资源
stmt.close();
} catch (SQLException e) {
e.printStackTrace();
}
}
if (conn != null) {
try {
//8.释放资源
conn.close();
} catch (SQLException e) {
e.printStackTrace();
}
}
}
return list;
}
//1.2定义一个Emp类：
@Data
@NoArgsConstructor
@AllArgsConstructor
public class Emp {
private int id;
private String ename;
private int job_id;
private int mgr;
private Date joindate;
private double salary;
private double bonus;
private int dept_id;
}
//1.3main方法调用查询方法：
public static void main(String[] args) {
List<Emp> list = new JdbcDemo().findAll();
System.out.println(list);
/**
* 输出结果：[Emp(id=1, ename=李三, job_id=1001, mgr=1001, joindate=2021-04-12, salary=5000.0, bonus=4000.0, dept_id=1001),
* Emp(id=2, ename=王五, job_id=1002, mgr=1002, joindate=2021-04-04, salary=6000.0, bonus=5000.0, dept_id=1002)]
*
*/
}
5.if语句结构
//if语句结构
int time = 25;
if(time >=0 && time <=12){
System.out.println("上午好");
}else if(13<=time && time<=18){
System.out.println("下午好");
}else if(19<=time && time<=24){
System.out.println("晚上好");
}else{
System.out.println("输入错误");
}
6.switch语句结构
//switch语句结构
@Test
public void test(){
doWhat(8);
}
public void doWhat(int day) {
if (day>7 || day<1){
System.out.println("您输入错误，请重新输入");
return;
}
switch (day) {
case 1:
System.out.println("星期一");
break;
case 2:
System.out.println("星期二");
break;
case 3:
System.out.println("星期三");
break;
case 4:
System.out.println("星期四");
break;
case 5:
System.out.println("星期五");
break;
case 6:
System.out.println("星期六");
break;
case 7:
System.out.println("星期天");
break;
}
7.星期枚举类
//星期枚举类：
public enum Week {
星期一,星期二,星期三,星期四,星期五,星期六,星期天
}
public class Student {
//枚举类型week
public Week day;
public void doWhat(Week day){
switch (day) {
case 星期一:
System.out.println("星期一");
break;
case 星期二:
System.out.println("星期二");
break;
case 星期三:
System.out.println("星期三");
break;
case 星期四:
System.out.println("星期四");
break;
case 星期五:
System.out.println("星期五");
break;
case 星期六:
System.out.println("星期六");
break;
case 星期天:
System.out.println("星期天");
break;
}
}
@Test
public void test(){
doWhat(Week.星期一); //输出结果：星期一
}
}
//上面可以写成如下方式：
public class Student {
//枚举类型week
public enum Week {
星期一,星期二,星期三,星期四,星期五,星期六,星期天
}
public void doWhat(Week day){
switch (day) {
case 星期一:
System.out.println("星期一");
break;
case 星期二:
System.out.println("星期二");
break;
case 星期三:
System.out.println("星期三");
break;
case 星期四:
System.out.println("星期四");
break;
case 星期五:
System.out.println("星期五");
break;
case 星期六:
System.out.println("星期六");
break;
case 星期天:
System.out.println("星期天");
break;
}
}
@Test
public void test(){
doWhat(Week.星期一); //输出结果：星期一
}
8.循环
8.1for 循环计算100以内的偶数和
//1.for 循环计算100以内的偶数和
int sum = 0;
for (int i = 1; i <=100 ; i++) {
if (i%2 ==0){
sum+=i;
}
System.out.println("sum:"+sum);
8.2while循环计算1+2+…+100的和
//2.while循环计算1+2+....+100的和
int i = 0;
int sum = 0;
while (i <= 100) {
sum += i;
i++;
}
System.out.println("sum:" + sum);
8.3do while 循环
//3.do while 循环
int count = 1;
boolean isOK = false;
do{
System.out.println("正在进行第"+count+"次练习");
if(count>=3){
isOK=true;
}
count++;
}while(!isOK);
8.4死循环
//4.死循环
//4.1 for死循环
for(;;){
//循环体
}
//4.2 while死循环
while (true){
//循环体
}
8.5在3个班按班级查找程序员同学为止
/**
5.按班级查找程序员同学，有3个班级，每班10个同学，假如第2个班级的第5
名同学叫程序员，找到该同学后则停止查找
*/
//1.通过for循环，获取到每一个班级
label_class:for (int i = 1; i < 4; i++) {
//2.在班级循环中，再次通过for循环获取到每个学生的信息
for (int j = 1; j < 11; j++) {
//3.打印当前学生的信息
System.out.println("正在查找第"+i+"班的第"+j+"个学生");
//4.判断当前学生是不是程序员
if (i==2 && j==5){
System.out.println("找到程序员同学了");
//5.如果是程序员，则结束指定循环
break label_class;
}
9. Random随机类
9.1获取1个随机数
//1.创建Random对象，获取1个随机数
Random r = new Random();
//2.获取（0，10）随机数，包含0，但是不包含10
int i = r.nextInt(10);
System.out.println(i);
9.2获取10个随机数
//2.获取10个随机数
Random r = new Random();
for (int i = 0; i < 10; i++) {
//2.获取随机数
int m = r.nextInt(10);
System.out.println(m);
}
9.3每次生成不同的随机数
//3.创建每次生成不同的随机数，不会重复的
//获取日期对象
Date date1 = new Date();
//获取当前时间的毫秒值
long time = date1.getTime();
//把毫秒值做放入Random里做参数，作为种子，种子每次不同，每次产生的随机数也就不同了
Random random = new Random(time);
//产生0到100的随机数
int i = random.nextInt(100);
System.out.println(i);
10.数组
10.1定义一个长度为3的整型数组
//定义一个长度为3的整型数组
int[] arr = new int[3];
10.2定义值为1，2，3的数组
//定义值为1，2，3的数组
int[] arr1 = {1,2,3};
10.3定义长度为5，值是1，2，3，4，5的数组
//定义长度为5，值是1，2，3，4，5的数组
int[] arr2 = new int[]{1,2,3,4,5};
10.4给数组赋值
/给arr1数组的第二个元素赋值
arr1[1]=4;
10.5遍历数组的所有元素
//遍历arr1数组的所有元素
for (int i = 0; i < arr1.length; i++) {
System.out.println(arr1[i]);
}
10.6比较两个数组里面的元素是否相同
//比较两个数组里面的元素是否相同
@Test
public void test6(){
int[] arr1 = {11,22,99,63};
int[] arr2 = {11,22,100,63};
boolean result = compare(arr1, arr2);
System.out.println(result); //输出结果：false
}
//定义一个比较两个数组元素是否相同的函数
public static boolean compare(int[] arr1,int[] arr2){
if(arr1.length!=arr2.length){
return false;
}
for (int i = 0; i < arr1.length; i++) {
if(arr1[i]!=arr2[i]){
return false;
}
}
return true;
}
11.抽象类
#1.有父类Employee,有成员经理manager和程序员coder
#因为父类中有共同的name,salary,id,work(),但是各不相同，所以方法可以定义为抽象方法
#其中Manager继承Employee, 有bonus和work()
#coder继承Employee, 有work()
11.1父类Employee
#父类Employee
public abstract class Employee {
//抽象类的成员变量
private String name;
private double salary;
private String id;
//无参构造方法
public Employee() {
}
//getter和setter
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public double getSalary() {
return salary;
}
public void setSalary(double salary) {
this.salary = salary;
}
public String getId() {
return id;
}
public void setId(String id) {
this.id = id;
}
//有参构造方法
public Employee(String name, double salary, String id) {
this.name = name;
this.salary = salary;
this.id = id;
}
//成员方法
public abstract void work();
}
}
11.2子类Manager类
#子类Manager类
public class Manager extends Employee {
//成员变量
private int bonus;
//getter和setter方法
public int getBonus() {
return bonus;
}
public void setBonus(int bonus) {
this.bonus = bonus;
}
//无参构造器
public Manager() {
}
//有参构造器
public Manager(String name, double salary, String id, int bonus) {
super(name, salary, id);
this.bonus = bonus;
}
//重写父类的成员方法
@Override
public void work() {
System.out.println("经理在工作");
}
}
11.3子类coder类
#子类coder类
public class Coder extends Employee {
@Override
public void work() {
System.out.println("程序员要敲代码");
}
}
11.4测试运行
#测试运行
public class TestDemo1 {
public static void main(String[] args) {
//创建多态程序员对象em
Employee em = new Coder();
em.work();
//创建多态经理对象em2
Employee em2 = new Manager("王五",60000,"研发部02",50000);
em2.work();
//下面是coder以面对对象的方式
Coder c = new Coder();
c.setName("张三");
c.setSalary(30000);
c.setId("研发部");
System.out.println("姓名："+c.getName());
System.out.println("薪水："+c.getSalary());
System.out.println("部门："+c.getId());
//Manger对象测试
Manager m = new Manager("李四",40000,"研发部01",10000);
System.out.println("姓名："+m.getName());
System.out.println("薪水："+m.getSalary());
System.out.println("部门："+m.getId());
System.out.println("奖金:"+m.getBonus());
}
}
12.接口
12.1创建接口
//1.创建接口
public interface USB {
//接口中没有构造方法，写了就报错
//成员常量
public static final int NUM = 10;
//成员方法
//JDK7及以前的写法
public abstract void open();
public abstract void close();
//JDK8多了两种写法
public static void method1(){
}
public default void method2(){
}
//JDK9多了一种写法
private void method3(){
}
}
//测试接口
public class TestDemo2 {
public static void main(String[] args) {
System.out.println(USB.NUM);
}
}
13.字符集进行编码，解码
@Test
public void test2() throws UnsupportedEncodingException {
//将字符串进行平台默认的字符集进行编码，UTF-8编码3个字节一个汉字，GBK编码2个字节一个汉字
String s ="中国";
byte[] bys = s.getBytes(); //使用平台默认的字符集编码
System.out.println(Arrays.toString(bys)); //输出编码：[-28, -72, -83, -27, -101, -67]
byte[] bys1 = s.getBytes("UTF-8"); //使用UTF-8进行编码
System.out.println(Arrays.toString(bys1)); //输出编码：[-28, -72, -83, -27, -101, -67]
byte[] bys2 = s.getBytes("GBK"); //使用GBK进行编码
System.out.println(Arrays.toString(bys2)); //输出编码：[-42, -48, -71, -6]
//下面进行解码，编码和解码方式必须要一致，什么方法编码的就要用什么方式解码
String s1 = new String(bys); //传入平台默认的字符集编码
System.out.println(s1); //平台默认字符集解码输出：中国
String s2 = new String(bys1,"UTF-8"); //按UTF-8进行解码
System.out.println(s2); //输出：中国
String s3 = new String(bys2,"GBK"); //按GBK方式解码
System.out.println(s3); //输出：中国
}
14.创建object类
//创建object类
Object obj = new Object();
Object obj1 = new Object();
//返回对象的哈希码值，每个对象的哈希码值不一样
int i = obj.hashCode();
System.out.println(i); //输出 381259350
14.1获取调用该对象的字节码文件对象
//获取调用该对象的字节码文件对象,一个类只有一个字节码文件对象
Class<?> Class1 = obj.getClass();
System.out.println(Class1); //输出 class java.lang.Object
14.2获取对象地址值
//获取对象地址值，是无符号十六进制的
String s = obj.toString();
System.out.println(s); //输出 java.lang.Object@16b98e56
14.3比较两个对象obj和obj1的地址值是否相等
//比较两个对象obj和obj1的地址值是否相等，一般都需要重写
boolean eq = obj.equals(obj1);
System.out.println(eq); //输出 false
14.4javabean重写Object类，重写euqals(),toString,hashCode()方法
//javabean重写Object类，重写euqals(),toString,hashCode()方法
public class TestDemo4 {
//成员变量
private int id;
private String name;
private int score;
//无参构造方法
public TestDemo4() {
}
//有参构造方法
public TestDemo4(int id, String name, int score) {
this.id = id;
this.name = name;
this.score = score;
}
//getter和setter
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getScore() {
return score;
}
public void setScore(int score) {
this.score = score;
}
//重写toString方法
@Override
public String toString() {
return "TestDemo4{" +
"id=" + id +
", name='" + name + '\'' +
", score=" + score +
'}';
}
//重写equals()方法和hashcode()方法
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
TestDemo4 testDemo4 = (TestDemo4) o;
return id == testDemo4.id && score == testDemo4.score && name.equals(testDemo4.name);
}
@Override
public int hashCode() {
return Objects.hash(id, name, score);
}
}
14.5测试上面的类
//测试上面的类
//测试toString()方法
TestDemo4 s1 = new TestDemo4(1,"欧阳修",66);
System.out.println(s1); //输出 TestDemo4{id=1, name='欧阳修', score=66}
//测试equals()方法
TestDemo4 s2 = new TestDemo4(1, "欧阳修", 63);
boolean eq = s1.equals(s2);
System.out.println(eq); //输出 false
/**
在前面的类方法中可以选择id,name,score其中几项相等就算两个对象相等的选择，我选定是三项
全部相等才算相等
*/
15.String类
15.1字节数组里面的整数转换成字母
//1.将字节数组里面的整数转换成字母
byte[] bys = {97,98,99};
String s = new String(bys);
System.out.println(s); //输出 abc
15.2将单个字母拼接成单词
//2.将单个字母拼接成单词
char[] cha = {'H','e','l','l','o'};
String s1 = new String(cha);
System.out.println(s1); //输出 Hello
//3.实际开发中可以String类可以免new
String s2 = "abc";
15.3比较两个字符串是否相等，区分大小写
//4.比较两个字符串是否相等，区分大小写
String s2 = "abc";
String s3 = "ABC";
boolean eq = s2.equals(s3);
System.out.println(eq); //输出 false
15.4不区分大小写比较两个字符串是否相等
//5.不区分大小写比较两个字符串是否相等
boolean eq1 = s2.equalsIgnoreCase(s3);
System.out.println(eq1); // 输出 true
15.5判断字符串是不是从字符a开头的
//6.判断字符串是不是从字符a开头的
boolean b = s2.startsWith("a");
System.out.println(b); //输出 true
15.6判断字符串是不是以字符c结尾的
//7.判断字符串是不是以字符c结尾的
boolean b1 = s2.endsWith("c");
System.out.println(b1); //输出 true
15.7判断字符串对象s2是不是空字符串
//8.判断字符串对象s2是不是空字符串
boolean em = s2.isEmpty();
System.out.println(em); //输出 false
15.8判断字符串对象s2的长度
//9.判断字符串对象s2的长度
int length = s2.length();
System.out.println(length); //输出3
15.9获取字符串对象s2索引1位置的字符
//10.获取字符串对象s2索引1位置的字符
char c = s2.charAt(1);
System.out.println(c); //输出b
15.9获取字符串对象s2字符c所在位子的索引
//11.获取字符串对象s2字符c所在位子的索引
int c1 = s2.indexOf("c");
System.out.println(c1); //输出 2
15.10获取字符串对象s4字符b最后出现所在位子的索引
//12.获取字符串对象s4字符b最后出现所在位子的索引
String s4 = "abcabc";
int m1 = s4.lastIndexOf("b");
System.out.println(m1); //输出 4
15.11截取字符串对象s4字符从索引2开始以后的所有字符
//13.截取字符串对象s4字符从索引2开始以后的所有字符
String sub1 = s4.substring(2);
System.out.println(sub1); //输出cabc
15.12截取字符串对象s4字符从索引2开始4结束，不包含4的所有字符
//14.截取字符串对象s4字符从索引2开始4结束，不包含4的所有字符
String sub2 = s4.substring(2, 4);
System.out.println(sub2); //输出 ca
15.13将字符串对象s2（“abc”）转换成字节数组
//15.将字符串对象s2（“abc”）转换成字节数组
byte[] by = s2.getBytes();
for (int i = 0; i < by.length; i++) {
System.out.println(by[i]); //输出 97 98 99 中间是换行符
}
15.14将字符串对象s2（“abc”）转换成字符数组
//16.将字符串对象s2（“abc”）转换成字符数组
char[] chars = s2.toCharArray();
for (int i = 0; i < chars.length; i++) {
System.out.println(chars[i]); //输出 a,b,c 中间是换行符
}
15.15将指定类型的数据转换成字符串类型数据
//17.将指定类型的数据转换成字符串类型数据
int a = 123;
String s5 = String.valueOf(a);
System.out.println(s5); //输出字符串类型的 “123”
15.16将字符串对象s2(“abc”)的字符b替换为d
//18.将字符串对象s2("abc")的字符b替换为d
String re = s2.replace("b", "d");
System.out.println(re); //输出 adc
15.17将字符串对象s2(“abc”)以空格进行切割，返回切割后的字符串数据，原字符串不受影响
//19.将字符串对象s2("abc")以空格进行切割，返回切割后的字符串数据，原字符串不受影响
String[] m2 = s2.split(" ");
for (int i = 0; i < m2.length; i++) {
System.out.println(m2[i]); //输出 abc
}
15.17去除字符串sb对象两边的空格
//20.去除字符串sb对象两边的空格
String sb = " a b c ";
String tri = sb.trim();
System.out.println(tri); //输出 a b c
16.容器
16.1创建StringBuilder对象容器
//1.创建StringBuilder对象容器
StringBuilder sb = new StringBuilder();
//往容器里面添加数据
sb.append("abc");
System.out.println(sb); //输出 abc
16.2将String字符串类型cdf转换成了StringBuilder类型
//2.将String字符串类型cdf转换成了StringBuilder类型
StringBuilder m = new StringBuilder("cdf");
System.out.println(m); //输出StringBuilder类型： cdf
16.3字符串拼接功能，将加入进去的字符串变成一句话输出
@Test
public void test7(){
//3.字符串拼接功能，将加入进去的字符串变成一句话输出
StringBuilder sb1 = new StringBuilder();
sb1.append("胡启行，");
sb1.append("爱编程，");
sb1.append("学习了java和python。");
System.out.println(sb1); //输出 胡启行，爱编程，学习了java和python。
//将输出结果进行反方向输出
StringBuilder sb2 = sb1.reverse();
System.out.println(sb2); //输出结果：。nohtyp和avaj了习学，程编爱，行启胡
//将sb1的StringBuilder类型转换成字符串String类型
String s2 = sb1.toString();
System.out.println(s2); //输出String类型结果：。nohtyp和avaj了习学，程编爱，行启胡
//还可以如下写链式编程：
sb1.append("，好好学习").append("，天天向上。");
System.out.println(sb1); //输出：。nohtyp和avaj了习学，程编爱，行启胡，好好学习，天天向上。
}
17.日期类
17.1创建Date对象
//1.创建Date对象
Date date1 = new Date();
System.out.println(date1); //输出 Fri Mar 26 19:15:09 CST 2021
17.2获取当前系统时间的毫秒值
//2.获取当前系统时间的毫秒值
long time = date1.getTime();
System.out.println(time); // 输出 1616757399810
17.3创建一个指定的时间
//3.创建一个指定的时间
Date date2 = new Date(1616757399810L);
System.out.println(date2); //输出 Fri Mar 26 19:16:39 CST 2021
17.4创建Calendar对象
//4.创建Calendar对象
Calendar ins = Calendar.getInstance();
System.out.println(ins);
/**
* 输出：java.util.GregorianCalendar[time=1616757696866,areFieldsSet=true,areAllFieldsSet=true,lenient=true,
* zone=sun.util.calendar.ZoneInfo[id="Asia/Shanghai",offset=28800000,dstSavings=0,useDaylight=false,
* transitions=31,lastRule=null],firstDayOfWeek=1,minimalDaysInFirstWeek=1,ERA=1,YEAR=2021,MONTH=2,
* WEEK_OF_YEAR=13,WEEK_OF_MONTH=4,DAY_OF_MONTH=26,DAY_OF_YEAR=85,DAY_OF_WEEK=6,DAY_OF_WEEK_IN_MONTH=4,
* AM_PM=1,HOUR=7,HOUR_OF_DAY=19,MINUTE=21,SECOND=36,MILLISECOND=866,ZONE_OFFSET=28800000,DST_OFFSET=0]
*/
//由于在java里面月份是0到11的，所以上面的月份是MONTH=2，表示现在是3月份
17.5获取Calendar对象的年月日时分秒
//5.获取Calendar对象的年月日时分秒
int year = ins.get(Calendar.YEAR);
int month = ins.get(Calendar.MONTH);
int day = ins.get(Calendar.DATE);
int hour = ins.get(Calendar.HOUR);
int minute = ins.get(Calendar.MINUTE);
int second = ins.get(Calendar.SECOND);
System.out.println(year+"年"+(month+1)+"月"+day+"日"+hour+"时"+minute+"分"+second+"秒");
/*输出：2021年3月26日7时32分57秒*/
17.6将时间设置成2022年2月2日
//6.将时间设置成2022年2月2日
ins.set(Calendar.YEAR,2022);
int year1 = ins.get(Calendar.YEAR);
ins.set(Calendar.MINUTE,2);
int month1 = ins.get(Calendar.MONTH);
ins.set(Calendar.DATE,2);
int day1 = ins.get(Calendar.DATE);
System.out.println(year1+"年"+month1+"月"+day1+"日"); // 输出 2022年2月2日
17.6将时间设置成2023年3月1日
//7.将时间设置成2023年3月1日
ins.set(2023, 3, 1);
int year2 = ins.get(Calendar.YEAR);
System.out.println(year2); //输出 2023
17.7创建 SimpleDateFormat 对象
/**
-创建 SimpleDateFormat 对象时必须指定转换格式。
-转换格式区分大小写，yyyy 代表年份，MM 代表月份，dd 代表日期，HH 代表 24 进制的小时，hh 代表 12 进制的小时，mm 代表分钟，ss 代表秒。
创建显示日期格式为：yyyy-MM-dd HH:mm:ss的对象
*/
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
try {
//1、日期转字符串
//创建Calendar对象
Calendar calendar = Calendar.getInstance();
//获取当前系统时间
Date date = calendar.getTime();
//将当前系统时间进行按yyyy-MM-dd HH:mm:ss进行格式化输出
String dateStringParse = sdf.format(date);
System.out.println(dateStringParse); //输出当前系统时间：2021-04-03 02:06:16
//2、字符串转日期
//字符串格式的日期时间
String dateString = "2017-12-20 14:02:08";
//转换成日期格式
Date dateParse = sdf.parse(dateString);
System.out.println(dateParse); // Wed Dec 20 14:02:08 CST 2017
} catch (ParseException e) {
e.printStackTrace();
}
/**
中文的日期还可以这样的格式输出：yyyy年MM月dd日 HH时mm分ss秒
按yyyy-MM-dd HH:mm:ss格式输出当前系统时间
*/
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
String current = sdf.format(System.currentTimeMillis());
System.out.println(current); //输出当前系统时间： 2021-04-03 02:16:33
Date date = new Date();
DateFormat df1 = DateFormat.getDateInstance();
System.out.println(df1.format(date)); //输出：2021年4月3日
DateFormat df2 = DateFormat.getDateTimeInstance();
System.out.println(df2.format(date)); //输出：2021年4月3日 上午2:29:33
DateFormat df3 = DateFormat.getTimeInstance();
System.out.println("只显示出时分秒:"+df3.format(date)); //输出只显示出时分秒:上午2:29:33
DateFormat df4 = DateFormat.getDateTimeInstance(DateFormat.FULL,DateFormat.FULL);
System.out.println("显示日期，周，上下午，时间(精确到秒):"+df4.format(date)); //输出显示日期，周，上下午，时间(精确到秒): 2021年4月3日星期六 中国标准时间 上午2:29:33
DateFormat df5 = DateFormat.getDateTimeInstance(DateFormat.LONG,DateFormat.LONG);
System.out.println("显示日期,上下午，时间(精确到秒):"+df5.format(date)); //输出显示日期,上下午，时间(精确到秒): 2021年4月3日 CST 上午2:29:33
DateFormat df6 = DateFormat.getDateTimeInstance(DateFormat.SHORT,DateFormat.SHORT);
System.out.println("显示日期，上下午,时间(精确到分):"+df6.format(date)); //输出显示日期，上下午,时间(精确到分): 2021/4/3 上午2:29
DateFormat df7 = DateFormat.getDateTimeInstance(DateFormat.MEDIUM,DateFormat.MEDIUM);
System.out.println("显示日期，时间(精确到分):"+df7.format(date)); //输出显示日期，时间(精确到分):2021年4月3日 上午2:29:33
17.8计算2021-03-03 11:11:11至今间隔多少天
//计算2021-03-03 11:11:11至今间隔多少天
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
String dateString = "2021-03-03 11:11:11";
Calendar calendar = Calendar.getInstance();
long nowDate = calendar.getTime().getTime(); //Date.getTime() 获得毫秒型日期
try {
long specialDate = sdf.parse(dateString).getTime();
long betweenDate = abs((specialDate - nowDate) / (1000 * 60 * 60 * 24)); //计算间隔多少天，则除以毫秒到天的转换公式
System.out.print(betweenDate);
} catch (ParseException e) {
e.printStackTrace();
}
17.9求出两个日期相差多少小时，分钟，毫秒
//求出两个日期相差多少小时，分钟，毫秒
DateFormat df = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
Date d1 = df.parse("2017-12-20 12:19:19");
Date d2 = df.parse("2017-12-20 11:40:34");
long nd = 1000 * 24 * 60 * 60;
long nh = 1000 * 60 * 60;
long nm = 1000 * 60;
long ns = 1000;
// 获得两个时间的毫秒时间差异
long diff = d1.getTime() - d2.getTime();
// 计算差多少天
long day = diff / nd;
// 计算差多少小时
long hour = diff % nd / nh;
// 计算差多少分钟
long min = diff % nd % nh / nm;
// 计算差多少秒//输出结果
long sec = diff % nd % nh % nm / ns;
System.out.println(day + "天" + hour + "小时" + min + "分钟"+ sec + "秒"); //输出：0天0小时38分钟45秒
18.Math类
//Math类：自然对数的底数是E，是一个常量，圆周率：PI
@Test
public void test4(){
System.out.println(Math.abs(-88)); //输出绝对值：88
System.out.println(Math.ceil(12.34)); //向上输出：13.0
System.out.println(Math.ceil(12.56)); //向上输出：13.0
System.out.println(Math.round(12.34)); //输出：12 四舍五入
System.out.println(Math.round(12.56)); //输出：13
System.out.println(Math.max(23, 77)); //取最大值：77
System.out.println(Math.min(23, 77)); //取最小值：23
System.out.println(Math.pow(2.0, 3.0)); //求出2的3次方=8
System.out.println(Math.random()); //输出0-1之间的随机数：0.7961397464788406
System.out.println(Math.random()*100); //输出0-100之间的随机数：83.77992943321254
}
18.1终止当前的虚拟机运行，计算运行时间用的方法，获取当前系统时间的毫秒值
System.exit(0);//终止当前的虚拟机运行
@Test
public void test5() {
System.out.println(System.currentTimeMillis()); //获取当前系统时间的毫秒值：1618147230411
System.out.println(System.currentTimeMillis() * 1.0 / 1000 / 60 / 60 / 24 / 365 + "年"); //输出当前时间经过了多少年：51.3111166609589年
//常用来计算运行时间用的方法，从这里开始计时
long start = System.currentTimeMillis();
for (int i = 0; i < 100000; i++) {
System.out.println(i);
}
//从这里结束计时
long end = System.currentTimeMillis();
System.out.println("程序一共运行了："+(end-start)+"毫秒"); //输出：程序一共运行了：1945毫秒
}
19.类型转换
/**
#由于基本的int,char,byte等基本数据类型不是对象，不可以通过.的方式调用方法，所以才有了包装类
包装类有：
基本类型 包装类
* byte Byte
* short Short
* int Integer
* long Long
* char Character
* float Float
* double Double
* boolean Boolean
*/
19.1Integer类型转成int类型
/1.Integer类型转成int类型
//1.装箱 包装类i2
Integer i2 = 30;
//拆箱
int c = i2;
19.2将字符串类型的“10”转成成int类型的10
//2.将字符串类型的“10”转成成int类型的10
String s = "10";
int i = Integer.parseInt(s);
/**
XXX.parseXXX(a), 是将a转换成XXX类型,Character没有这个方法，其他类型都有，如：Float.parseFloat()
*/
19.3存取包装类
@Test
public void test(){
//集合中只能存取包装类，不能存取基本数据类型
//包装类型转成基本类型：XXXValue()方法
Integer i = 10;
int iNum = i.intValue();
System.out.println(iNum); //输出int类型：10
//基本数据类型转换成字符串类型
String s = 100 + ""; //将int 100转成了字符串
String s2 = true + ""; //将boolean类型转成了字符串
//基本数据类型转成字符串
int num = 100;
String snum = Integer.toString(num); //将int 100转成了字符串
//基本类型转成包装类
int j = 90;
Integer j1 = Integer.valueOf(j); //将int类型转换成Interger类型
}
19.4多个字符串转换成list集合
//1.多个字符串转换成list集合，这个集合大小是固定的，所以不可以添加或删除元素改变集合大小，但可以改变已经有的元素
@Test
public void test2(){
List<String> list = Arrays.asList("java","ni","hao");
System.out.println(list); //输出：[java, ni, hao]
}
//2.产生不可变的list集合，这个list不可以做增加删除更改操作
@Test
public void test2(){
List<String> list = List.of("java","ni","hao");
System.out.println(list); //输出：[java, ni, hao]
}
//3.不可变不重复集合，重复元素就会报错
@Test
public void test2(){
Set<String> set = Set.of("java","ni","hao");
System.out.println(set); //输出：[hao, java, ni]
}
20.集合
public class Student {
public String name;
public int age;
public Student() {
}
public Student(String name, int age) {
this.name = name;
this.age = age;
}
@Override
public String toString() {
return "Student{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
}
20.1创建list集合
public class TestDemo4 {
public static void main(String[] args) {
//1.创建list集合对象
List list1 = new ArrayList();
//2.创建Student对象
Student stu1 = new Student("乔峰",41);
Student stu2 = new Student("乔峰",41);
Student stu3 = new Student("段誉",46);
Student stu4 = new Student("虚竹",35);
//3.将对象添加到集合中
list1.add(stu1);
list1.add(stu2);
list1.add(stu3);
list1.add(stu4);
System.out.println(list1);
/**
输出结果 [Student{name='乔峰', age=41}, Student{name='乔峰', age=41}, Student{name='段誉', age=46}, Student{name='虚竹', age=35}]
*/
20.2输出索引为2的元素对象
//4.输出索引为2的元素对象
Object m = list1.get(2);
System.out.println(m); //输出 Student{name='段誉', age=46}
20.3普通的for遍历list集合
//5.普通的for遍历list集合
for (int i = 0; i < list1.size(); i++) {
Object m1 = list1.get(i);
System.out.println(m1);
/**
* 输出结果：
* Student{name='乔峰', age=41}
* Student{name='乔峰', age=41}
* Student{name='段誉', age=46}
* Student{name='虚竹', age=35}
*/
}
20.4增强for遍历list集合
//6.增强for遍历list集合，快捷键 iter
for (Object m1 : list1) {
System.out.println(m1);
}
/**
* 输出结果：
* Student{name='乔峰', age=41}
* Student{name='乔峰', age=41}
* Student{name='段誉', age=46}
* Student{name='虚竹', age=35}
*/
20.5迭代器是遍历Collections集合的通用方式
//7.迭代器是遍历Collections集合的通用方式，不但可以遍历还可以同时进行增加或删除操作,对于list集合遍历的同时也可以增加删除操作，独有的
//创建迭代器对象
Iterator it = list1.iterator();
while (it.hasNext()){ //如果迭代器中有元素，就一直迭代
Object s = it.next(); //获取元素
//String s = (String)it.next(); 有需要的要强制转换成字符串格式，在这里不能转换，会报错
System.out.println(s);
}
/** 输出结果：
* Student{name='乔峰', age=41}
* Student{name='乔峰', age=41}
* Student{name='段誉', age=46}
* Student{name='虚竹', age=35}
*/
20.6迭代器遍历的同时增加元素
//7.1迭代器遍历的同时增加元素java
List list = new ArrayList();
list.add("a");
list.add("b");
list.add("c");
Iterator lit = list.iterator();
while (lit.hasNext()) { //如果迭代器中有元素，就一直迭代
String s = (String) lit.next(); //有需要的要强制转换成字符串格式
if ("b".equals(s)) {
lit.add("b");
}
System.out.println(s); //输出 a,b,java,c
}
}
}
20.7创建了只能存储String类型数据的List集合
//8.创建了只能存储String类型数据的List集合，不可以进行数据类型转换，起到了数据保护的作用
//泛型一般只和集合结合使用
List<String> lit = new ArrayList<>();
20.8Collections工具类是专门用来对集合进行操作用
20.8.1添加元素
//9.Collections工具类是专门用来对集合进行操作用的
//创建了只能存储String类型数据的List集合，不可以进行数据类型转换，起到了数据保护的作用
List<Integer> lit = new ArrayList<>();
lit.add(1);
lit.add(2);
lit.add(3);
lit.add(4);
lit.add(5);
lit.add(6);
lit.add(7);
System.out.println(lit); //输出 [1, 2, 3, 4, 5, 6, 7]
20.8.2集合最大值，最小值
Integer max = Collections.max(lit);
System.out.println(max); //输出 7
Integer min = Collections.min(lit);
System.out.println(min); //输出 1
20.8.3集合排序
//list集合进行升序排列
Collections.sort(lit);
System.out.println(lit); //输出 [1, 2, 3, 4, 5, 6, 7]
//对集合进行逆序排列
Collections.reverse(lit);
System.out.println(lit); //输出 [7, 6, 5, 4, 3, 2, 1]
//对集合进行随机排序
Collections.shuffle(lit);
System.out.println(lit); //输出 [3, 7, 1, 5, 4, 6, 2]
20.9Set集合
//10.Set集合 无序，不能重复
//1.创建set集合对象，这里面的参数需要放入的是Student类里的对象
Set<Student> set = new HashSet<>();
//2.创建Student对象（这个对象里面有重复的乔峰），对于set集合不能有重复的对象
//所以在Student类中，需要重写equals()和hashcode()方法进行去重操作
Student stu1 = new Student("乔峰",41);
Student stu2 = new Student("乔峰",41);
Student stu3 = new Student("段誉",46);
Student stu4 = new Student("虚竹",35);
20.9.1Set集合添加元素对象
//3.set集合添加元素对象
set.add(stu1);
set.add(stu2);
set.add(stu3);
set.add(stu4);
System.out.println(set);
/**
* 输出： 在Student类中，没有重写的时候，重复的元素在里面
* [Student{name='虚竹', age=35}, Student{name='乔峰', age=41}, Student{name='乔峰', age=41},
* Student{name='段誉', age=46}]
* 输出： 在Student类中，重写equals()和hashcode()方法后：
* [Student{name='虚竹', age=35}, Student{name='段誉', age=46}, Student{name='乔峰', age=41}]
*/
20.10Map集合
//11.Map集合：有key和value，key不可以重复，value可以重复
//1.创建Map对象，对象是Student类，值是Integer类型
Map<Integer,Student> map = new HashMap<>();
//2.创建Student对象
Student stu1 = new Student("乔峰",41);
Student stu2 = new Student("杨过",41);
Student stu3 = new Student("段誉",46);
Student stu4 = new Student("虚竹",35);
20.10.1Map集合加入元素
//3.Map集合加入元素对象
map.put(1,stu1);
map.put(2,stu2);
map.put(3,stu3);
map.put(4, stu4);
20.10.2Map集合根据Key获取键值
//4.根据Key获取键值
Student ss = map.get(2);
System.out.println(ss); //输出 Student{name='杨过', age=41}
20.10.3迭代器遍历Map集合
/5.迭代器遍历Map集合
//1.获取所有键key的List集合
Set<Integer> keys = map.keySet();
//2.创建key的list集合迭代器对象
Iterator<Integer> it = keys.iterator();
while (it.hasNext()) { //如果迭代器中有元素，就一直迭代
Integer key = it.next(); //获取元素，key的数据类型Integer要和Map的键数据类型一致
//String key = (String)it.next(); 有需要的要强制转换成字符串格式，在这里不能转换，会报错
Student values = map.get(key);
System.out.println("Key" + key + "......vaules:" + values);
/**
* 输出：
* Key1......vaules:Student{name='乔峰', age=41}
* Key2......vaules:Student{name='杨过', age=41}
* Key3......vaules:Student{name='段誉', age=46}
* Key4......vaules:Student{name='虚竹', age=35}
*/
}
20.10.4通过增强for遍历Map集合
//通过增强for遍历Map集合
//1.获取所有键key的List集合
Set<Integer> keyss = map.keySet();
for (Object m1 : keyss) {
Student values = map.get(m1);
System.out.println(values);
}
/**
* 输出：
* Student{name='乔峰', age=41}
* Student{name='杨过', age=41}
* Student{name='段誉', age=46}
* Student{name='虚竹', age=35}
*/
20.11案例:模拟斗地主
//综合案例：模拟斗地主
int num = 0; //定义牌的编号
//1.定义一个双列集合 key：Integer 对应的值是牌
Map<Integer,String> pokers = new HashMap<>();
//2.定义一个List存放所有的牌的编号,牌编号是Integer类型
List<Integer> list =new ArrayList<>();
//3.用数组合成一副牌
String[] colours = {"红桃","黑桃","梅花","方片"};
String[] numbers = {"2","3","4","5","6","7","8","9","10","J","Q","K","A"};
//将花色和牌数字一起组合形成牌
for (String colour : colours) { //获取所有的花色
for (String number : numbers) { //获取所有的点数
String poker = colour + number; //花色和点数组合成牌
//将牌的编号和具体的牌放到双列集合Map集合中
pokers.put(num,poker);
//将牌的编号放到单列集合List集合中
list.add(num);
num++;
}
}
//Map集合中添加大王
pokers.put(num, "大王");
//List集合增加大王的序号
list.add(num++);
pokers.put(num, "小王");
list.add(num++);
//打印所有的牌
System.out.println(pokers);
/**
* 输出：
* {0=红桃2, 1=红桃3, 2=红桃4, 3=红桃5, 4=红桃6, 5=红桃7, 6=红桃8, 7=红桃9, 8=红桃10, 9=红桃J, 10=红桃Q,
* 11=红桃K, 12=红桃A, 13=黑桃2, 14=黑桃3, 15=黑桃4, 16=黑桃5, 17=黑桃6, 18=黑桃7, 19=黑桃8, 20=黑桃9,
* 21=黑桃10, 22=黑桃J, 23=黑桃Q, 24=黑桃K, 25=黑桃A, 26=梅花2, 27=梅花3, 28=梅花4, 29=梅花5, 30=梅花6,
* 31=梅花7, 32=梅花8, 33=梅花9, 34=梅花10, 35=梅花J, 36=梅花Q, 37=梅花K, 38=梅花A, 39=方片2, 40=方片3,
* 41=方片4, 42=方片5, 43=方片6, 44=方片7, 45=方片8, 46=方片9, 47=方片10, 48=方片J, 49=方片Q, 50=方片K,
* 51=方片A, 52=大王, 53=小王}
*/
//洗牌,把存放牌编号的list进行随机打乱
Collections.shuffle(list);
//发牌，三个人，定义4个集合，三个集合存放人获得牌，第四个集合存放底牌
List<Integer> liuyifei = new ArrayList<>();
List<Integer> zhaoliying = new ArrayList<>();
List<Integer> xiaohei = new ArrayList<>();
List<Integer> dipai = new ArrayList<>();
//将索引除3取模决定发牌给谁
for (int i = 0; i < list.size(); i++) {
//获取牌的编号
Integer pokerNum = list.get(i);
if (i >= list.size() - 3) {
//底牌
dipai.add(pokerNum);
} else if (i % 3 == 0) {
liuyifei.add(pokerNum);
} else if (i % 3 == 1) {
zhaoliying.add(pokerNum);
} else if (i % 3 == 2) {
xiaohei.add(pokerNum);
}
}
//查看玩家和底牌 这里获取的是每个人牌的编号
System.out.println("刘亦菲："+liuyifei);
System.out.println("赵丽引:"+zhaoliying);
System.out.println("小黑："+xiaohei);
System.out.println("底牌："+dipai);
/**
* 输出：
* 刘亦菲：[51, 46, 6, 52, 28, 2, 53, 25, 23, 18, 49, 48, 43, 15, 21, 27, 20]
* 赵丽引:[4, 26, 41, 11, 10, 45, 36, 30, 34, 40, 50, 42, 16, 47, 31, 33, 0]
* 小黑：[1, 8, 17, 39, 12, 22, 5, 29, 35, 7, 37, 3, 14, 38, 44, 24, 19]
* 底牌：[32, 9, 13]
*/
//获取每个人的具体的牌，另外创建了一个现实具体牌的类sendpoker类，里面有静态方法printpoker方法
//调用静态的方法可以是 sendpokerTest.printpoker() 也可以是下面的调用方法不用写类名，
//可以在这上面的函数继承sendpokerTest即可：extends sendPokerTest
String str1 = printPoker(liuyifei, pokers);
System.out.println("刘亦菲："+str1);
String str2 = printPoker(zhaoliying, pokers);
System.out.println("赵丽引："+str2);
String str3 = printPoker(xiaohei, pokers);
System.out.println("小黑："+str3);
String str4 = printPoker(dipai, pokers);
System.out.println("底牌："+str4);
/**
* 输出：
* 刘亦菲：红桃2 红桃9 黑桃2 黑桃5 黑桃6 黑桃7 黑桃8 黑桃10 梅花4 梅花6 梅花A 方片2 方片3 方片6 方片7 方片9 方片10
* 赵丽引：红桃3 红桃5 红桃10 红桃J 红桃K 黑桃4 黑桃9 黑桃J 黑桃Q 梅花5 梅花9 梅花J 梅花K 方片5 方片Q 方片K 大王
* 小黑：红桃4 红桃6 红桃7 红桃8 红桃Q 红桃A 黑桃A 梅花2 梅花3 梅花8 梅花10 梅花Q 方片4 方片8 方片J 方片A 小王
* 底牌：黑桃3 黑桃K 梅花7
*/
//看牌，根据牌的编号获取牌，这个需要另外定义一个类来完成操作：
public class sendPokerTest {
public static String printPoker(List<Integer> nums, Map<Integer,String> pokers){ //传入一个List放牌 的编号，一个Map放牌的集合
//1.对牌的编号就行升级排序
Collections.sort(nums);
//2.遍历牌的集合获取每一个牌的编号
//创建StringBuilder容器存放牌
StringBuilder sb = new StringBuilder();
for (Integer num : nums) {
//根据编号去Map集合中去获取编号对应的具体的牌
String poker = pokers.get(num);
//将获取到的牌用空格进行拼接
sb.append(poker+" ");
}
//3.将最后拼到的结果进行返回
String str = sb.toString();
//去除字符串两边的空格
return str.trim();
}
}
20.12Hashset哈希表
/**1. Hashset底层数据结构是哈希表，存入的数据和取出的数据元素位置不一致
* 没有索引，不可以通过for遍历，不包含重复元素
*/
//创建集合对象
HashSet<String> hs = new HashSet<String>();
//添加元素
hs.add("hello");
hs.add("world");
hs.add("java");
//遍历
for (String h : hs) {
System.out.println(h); //输出：world java hello
}
//2.创建一个Student类，里面有private name和age属性，getter,setter方法，tostring()方法
//创建集合对象
HashSet<Student> hs = new HashSet<Student>();
Student stu= new Student("林青霞","30");
Student stu1 = new Student("张曼玉","26");
Student stu2 = new Student("王祖贤","63");
//添加元素
hs.add(stu);
hs.add(stu1);
hs.add(stu2);
//遍历
for (Student h : hs) {
System.out.println(h.getName()+" "+h.getAge()); //输出：林青霞 30 张曼玉 26 王祖贤 63
}
20.13linkedHashSet集合
/** linkedHashSet集合具有可预测的迭代次序
* 存储和取出顺序是一致的，由哈希表保证元素的唯一性，没有重复元素
*/
//创建集合对象
LinkedHashSet<String> hs = new LinkedHashSet<String>();
//添加元素
hs.add("java");
hs.add("world");
hs.add("hello");
//遍历
for (String h : hs) {
System.out.println(h); //输出：java world hello
}
20.14TreeSet集合
/** 1.TreeSet():根据元素的自然排序进行排序
* TreeSet(Comparator comparator):根据指定的比较器进行排序
* 不能使用普通的for遍历，没有索引，不包含重复元素
*/
//创建集合对象
TreeSet<Integer> hs = new TreeSet<Integer>();
//添加元素
hs.add(10);
hs.add(40);
hs.add(30);
hs.add(90);
hs.add(70);
//遍历
for (Integer h : hs) {
System.out.println(h); //输出：10 30 40 70 90 按自然排序就是从小到大排序
}
/** 1.TreeSet():根据元素的自然排序进行排序
* TreeSet(Comparator comparator):根据指定的比较器进行排序
* 不能使用普通的for遍历，没有索引，不包含重复元素
*/
//创建集合对象
TreeSet<Student> hs = new TreeSet<Student>();
Student stu = new Student("西施","23");
Student stu1 = new Student("大桥","56");
Student stu2 = new Student("小乔","12");
Student stu3 = new Student("王昭君","78");
Student stu4 = new Student("貂蝉","26");
//添加元素
hs.add(stu);
hs.add(stu1);
hs.add(stu2);
hs.add(stu3);
hs.add(stu4);
//遍历
for (Student h : hs) {
System.out.println(h.getName()+","+h.getAge());
//输出：当下面的Student类的return值设置为0的时候，输出结果：西施,23 （0输出第一个元素）
/**输出：当下面的Student类的return值设置为1的时候，输出结果： （1输出按顺序输出）
西施,23
大桥,56
小乔,12
王昭君,78
貂蝉,26
*/
/**输出：当下面的Student类的return值设置为-1的时候，输出结果： （-1输出按倒序输出）
貂蝉,26
王昭君,78
小乔,12
大桥,56
西施,23
*/
/**输出：当下面的Student类的return值设置为i的时候，
输出结果：return this.age-s.age 按年龄从小到大排列 ，如果return s.age-this.age，那就是年龄从大到小排列了
小乔,12
西施,23
貂蝉,26
大桥,56
王昭君,78
*/
}
/**2.创建一个Student类，里面有private name和age属性，getter,setter方法，tostring()方法,
并且这个类 继承：
public class Student implements Comparable<Student>{
//2.1最后有一个重写方法：
@Override
public int compareTo(Student S) {
return 0; //这个return值可以设置为0或1或-1，对应的上面的输出结果不同
}
//2.2重写方法还可以如下写：（因为的age是private String类型，所以要做一个转换）
@Override
public int compareTo(Student s) {
int i = Integer.parseInt(this.age)-Integer.parseInt(s.age);
return i;
}
//2.2当age定义的是int类型的时候写法如下：
@Override
public int compareTo(Student s) {
int i = this.age - s.age;
return i;
}
//年龄从小到大排列，年龄相同的时候，名字按拼音排列
public int compareTo(Student s) {
//按照年龄的顺序排列从小到大
int i = Integer.parseInt(this.age) - Integer.parseInt(s.age);
//年龄相同的话，按照名字字母顺序排列
int i1 = i == 0 ? this.name.compareTo(s.name) : i;
return i1;
}
20.15Collection集合
@Test
public void Test() {
//创建Collection集合
Collection col = new ArrayList();
//集合中添加元素
col.add("java");
col.add("hello");
col.add("world");
//迭代器遍历集合
Iterator it = col.iterator();
while (it.hasNext()) { //如果迭代器中有元素，就一直迭代
String next = (String)it.next();
System.out.println(next); //输出：java hello world
}
20.16Properties集合
//Properties集合
@Test
public void test2(){
//创建Properties集合对象（和map集合很类似）
Properties pro = new Properties();
//添加对象
pro.put("0001", "李刚");
pro.put("0002", "王五");
//遍历集合
Set<Object> keyss = pro.keySet();
for (Object key : keyss) {
Object values = pro.get(key);
System.out.println(key+","+values);
}
/**
* 输出结果：
* 0002,王五
* 0001,李刚
*/
}
@Test
public void test2() throws IOException {
//1.创建Properties集合对象（和map集合很类似）
Properties pro = new Properties();
//2.添加对象可以使用特有的方法setProperty
pro.setProperty("0001", "李刚");
pro.setProperty("0002", "王五");
//3.获取结果
System.out.println(pro.getProperty("0001")); //输出：李刚
System.out.println(pro.getProperty("00012")); //对于不存在的key值：输出：null
System.out.println(pro); //输出：{0002=王五, 0001=李刚}
//4.只获取key值，返回一个不可修改的键集
Set<String> names = pro.stringPropertyNames();
for (String key : names) {
System.out.println(key); //输出结果：0002 0001
//获取所有键值
String value = pro.getProperty(key);
System.out.println(key+","+value); //输出结果： 0002，王五 0001，李刚
}
//5.把集合中的数据保存到文件1.txt，创建对象
FileWriter fw = new FileWriter("D:\\project\\src\\test\\java\\com\\qy\\spring5\\testdemo\\1.txt");
//写入保存文件
pro.store(fw, null);
//关闭资源
fw.close();
/**
* 1.txt里面的内容结果：
* #Sun Apr 11 20:35:53 CST 2021
* 0002=王五
* 0001=李刚
*
*/
}
20.17ArrayList集合
//ArrayList集合
@Test
public void test8(){
/**
*ArrayList<E>:
* 是可调整大小的数组实现
* <E>:是一种特殊的数据类型，表示泛型
*/
//创建ArrayList对象
ArrayList<String> array = new ArrayList<>();
//添加元素
array.add("hello");
array.add("java");
System.out.println("array:"+array); //输出：array:[hello, java]
array.add(1,"胡启行");
System.out.println("array:"+array); //输出：array:[hello, 胡启行, java]
//删除hello元素
array.remove("hello");
System.out.println("array:"+array); //输出：array:[胡启行, java]
//删除索引为1的元素
array.remove(1);
System.out.println("array:"+array); //输出：array:[胡启行]
//更改元素
array.set(0, "胡启航");
System.out.println(array); //输出：[胡启航]
//获取指定处索引元素值
System.out.println(array.get(0)); //输出：胡启航
//获取集合中元素个数
System.out.println(array.size()); //输出：1
//遍历集合
for (int i = 0; i < array.size(); i++) {
System.out.println(array.get(i)); //输出：胡启航
}
}
21.try catch
//1.选中要执行的代码片段，try catch快捷键是 Ctrl+alt+t
try {
//尝试要执行的代码
int a = 10 /0 ;
} catch (Exception e) {
//出现问题后的解决方案
System.out.println("被除数不能为0");
} finally {
//不管如何要执行的代码
System.out.println("看看我执行了么");
}
/**
* 输出：
* 被除数不能为0
* 看看我执行了么
*/
22.IO流
22.1创建IO流对象
//2.IO流能在本地磁盘和网络上操作数据
//将D:/abc/1.txt这个文件封装成File对象
//方式一
File file1 = new File("D:/abc/1.txt");
//方式二
File file2 = new File("D:/abc/","1.txt");
//方式三
File file3 = new File("D:/abc/");
File file4 = new File(file3,"1.txt");
22.2创建1.txt文件
//3.创建1.txt文件
String wenJian = "D:/1.txt";
File file5 = new File(wenJian);
boolean newFile = file5.createNewFile();
if (newFile) {
System.out.println("创建:" + wenJian + "成功");
}else {
System.out.println("创建失败");
}
22.3创建单级文件夹
//4.创建单级文件夹a
File file6 = new File("D:/a");
boolean newFile1 = file6.mkdir(); //只能创建单级目录
22.4创建多级文件夹
//5.创建多级文件夹
File file7 = new File("D:/a/b/c");
file7.mkdirs();
boolean fi = file7.isFile(); //是否是文件 false
boolean ex = file7.exists(); //是否存在 true
boolean dir = file7.isDirectory(); //是否是目录 true
22.5获取绝对路劲
//6.获取绝对路劲
File file = new File("lib/2.txt");
File absoluteFile = file.getAbsoluteFile(); //获取 lib/2.txt的绝对路径
System.out.println(absoluteFile);
//输出：C:\Users\Administrator\IdeaProjects\maven01\src\test\lib\2.txt
22.6获取相对路劲
//6.获取相对路劲
String path = file.getPath(); //获取相对路劲
System.out.println(path); //输出 lib\2.txt
22.6获取文件名
//7.获取文件名
String name = file.getName(); //获取文件名
System.out.println(name); //输出 2.txt
22.7获取所有文件夹名称
//8.这个lib文件夹Directory必须是在项目文件夹下面建立的文件夹根目录下，才能找到
//我创建的lib 里面有 abc文件夹，里面有1.txt， /a/b文件夹里面有2.txt
File file2 = new File("lib");
String[] names = file2.list(); //获取lib文件夹里面的所有文件夹名称，String[]数组类型
for (String name : names) {
System.out.println(name); //输出 a ,abc
}
22.8获取所有文件夹和文件的名称
File[] file3 = file2.listFiles(); //获取lib文件夹里面的所有文件夹和文件的名称，File[]数组类型，如果lib根目录下有文件，也会显示出来
for (File fi : file3) {
System.out.println(fi); //输出 lib\a，lib\abc
}
22.9文件复制拷贝
//一.将D:\\itcast目录文件夹里面的所有文件复制拷贝一份到Java项目文件下的myCharStream\\itcast目录中（注意D:\\itcast目录里面没有文件夹，只有文件才可以，单级文件夹）：
public static void main(String[] args) throws IOException {
//1.创建数据源目录File对象，D：\\itcast文件夹
File srcFolder = new File("D:\\itcast");
//2.获取文件名itcast
String srcFolderName = srcFolder.getName();
//3.创建目的地目录File对象,路劲是：myCharStream\\itcast
File destFolder = new File("myCharStream",srcFolderName);
//4.判断目的地的目录File对象是否存在，如果不存在就创建
if(!destFolder.exists()){
destFolder.mkdirs();
}
//5.获取数据源目录下所有文件的File数组
File[] listfiles = srcFolder.listFiles();
//6.遍历，得到每一个File对象爱，该File对象就是数据源文件
for (File srcFile : listfiles) {
//获取对象名称
String srcFileName = srcFile.getName();
//创建目的地文件File对象
File destFile = new File(destFolder, srcFileName);
//复制文件
TestDemo2.copyFile(srcFile,destFile);
}
}
//批量复制目录文件的方法
private static void copyFile(File srcFile,File destFile) throws IOException {
BufferedInputStream bis = new BufferedInputStream(new FileInputStream(srcFile));
BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(destFile));
byte[] bys = new byte[1024];
int len;
while ((len = bis.read(bys)) != -1) {
bos.write(bys,0,len);
}
bis.close();
bos.close();
}
22.10所有目录和文件（包括多级目录),复制
//二.将D：\\itcast文件夹里面所有目录和文件（包括多级目录），复制到D:\\a文件夹中
public static void main(String[] args) throws IOException {
//1.创建数据源目录File对象，D：\\itcast文件夹
File srcFile = new File("D:\\itcast");
//2.创建目的地File对象，路劲是F：\\
File destFile = new File(("D:\\a"));
//3.复制文件
TestDemo2.copyFolder(srcFile,destFile);
}
private static void copyFolder(File srcFile,File destFile) throws IOException {
//判断数据源File是不是目录
if(srcFile.isDirectory()) {
//在目的地下创建和数据源File名称一样的目录
String srcFileName = srcFile.getName();
File newFolder = new File(destFile, srcFileName);
if (!newFolder.exists())
newFolder.mkdirs();
//获取数据源File下所有文件或者目录的File数组
File[] fileArray = srcFile.listFiles();
//遍历该File数组，得到每一个File对象
for (File file : fileArray) {
//把该File作为数据源File对象，递归调用复制文件夹的方法
copyFolder(file, newFolder);
}
} else{
//说明是文件，直接复制，用字节流
File newFile = new File(destFile, srcFile.getName());
copyFile(srcFile,newFile);
}
}
private static void copyFile(File srcFile,File destFile) throws IOException {
BufferedInputStream bis = new BufferedInputStream(new FileInputStream(srcFile));
BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(destFile));
byte[] bys = new byte[1024];
int len;
while ((len = bis.read(bys)) != -1) {
bos.write(bys, 0, len);
}
bis.close();
bos.close();
}
22.11遍历目录并将所有文件的绝对路劲输出到控制台，多层级文件夹里面的文件路径也可以输出
//三.遍历目录并将所有文件的绝对路劲输出到控制台，多层级文件夹里面的文件路径也可以输出
@Test
public void test3(){
//给定的路劲创建一个File对象
File srcFile = new File("D:\\itcast");
//调用方法，获取所有文件路劲
getAllFilepath(srcFile);
}
public static void getAllFilepath(File srcFile){
//获取给定的File目录下所有的文件或目录的File数组
File[] fileArry = srcFile.listFiles();
//遍历该数组，得到每一个File对象
if(fileArry != null){
for (File file : fileArry) {
//判断该对象是不是目录
if(file.isDirectory()){
//是的话递归调用
getAllFilepath(file);
}else {
//不是的话，获取绝对路径输出在控制台上
System.out.println(file.getAbsolutePath());
}
}
}
}
22.12读取一个字符
//9.IO流
//字符流是针对纯文本内容的
//读取一个字符 1.txt的内容是 abc
//9.1创建字符输入流对象
FileReader reader = new FileReader("lib/1.txt");
//读取数据
int read = reader.read();
System.out.println(read); //输出 97
//释放资源
reader.close();
22.13连续读取所有字符
//9.2 连续读取所有字符
//创建字符输入流对象
FileReader reader = new FileReader("lib/1.txt");
int ch;
while ((ch=reader.read())!=-1){
System.out.println(ch); // 输出 97 98 99
}
//释放资源
reader.close();
//9.3连续读取所有字符，创建字符输入流对象
FileReader reader = new FileReader("lib/1.txt");
//定义一个字符数组
char[] chs = new char[100]; //这个100表示每一行显示的最多字符个数是100
//记录读到的有效字符数
int len;
while ((len=reader.read(chs))!=-1){
String s = new String(chs, 0, len);
//要操作的数组：chs 起始索引：0，要操作的字符个数：len 将读到的内容转换成字符串
System.out.println(s); //输出1.txt的所有文本内容： abc
}
//释放资源
reader.close();
22.14创建字符输出流对象,一次写一个字
//10.创建字符输出流对象
FileWriter writer = new FileWriter("lib/1.txt");
writer.write("好人呀"); // 一次写一个字，一共写了3个字： 好人呀
//关闭资源
writer.close();
22.15创建字符输出流对象,一次写入一个指定的字符数组
//10.1创建字符输出流对象
FileWriter writer = new FileWriter("lib/1.txt");
//一次写入一个指定的字符数组
char[] chs = {'黑','马','程','序','员'};
writer.write(chs); //覆盖以前的内容写入：黑马程序员
writer.write(chs,0,2); //覆盖以前的内容写入指定长度的字符，从0开始写入2个字符：黑马
//关闭资源
writer.close();
22.16文件复制1.txt的内容写符到2.txt文件里面（字节流拷贝）
//10.3文件复制1.txt的内容写符到2.txt文件里面（字节流拷贝）
FileReader fr= new FileReader("lib/1.txt");
FileWriter fw = new FileWriter("lib/2.txt");
int len;
while ((len=fr.read())!=-1){
fw.write(len);
}
//关闭资源
fr.close();
fw.close();
22.17文件复制1.txt的内容写符到2.txt文件里面,按字符数组拷贝
//10.4文件复制1.txt的内容写符到2.txt文件里面,按字符数组拷贝
FileReader fr= new FileReader("lib/1.txt");
FileWriter fw = new FileWriter("lib/2.txt");
char[] chs =new char[1024];
int len;
while ((len=fr.read(chs))!=-1){
fw.write(chs,0,len);
}
//关闭资源
fr.close();
fw.close();
22.18字符缓冲流，文件复制1.txt的内容写符到2.txt文件里面
//11.字符缓冲流，文件复制1.txt的内容写符到2.txt文件里面
FileReader fr = new FileReader("lib/1.txt");
BufferedReader br = new BufferedReader(fr);
FileWriter fw = new FileWriter("lib/2.txt");
BufferedWriter bw = new BufferedWriter(fw);
//可以缩写如下：
BufferedReader br = new BufferedReader(new FileReader("lib/1.txt"));
BufferedWriter bw = new BufferedWriter(new FileWriter("lib/2.txt"));
int len;
while ((len = br.read()) != -1) {
bw.write(len);
}
//释放资源
br.close();
bw.close();
22.19字符缓冲流，文件复制1.txt的内容写符到2.txt文件里面，一行一行读取
//12.字符缓冲流，文件复制1.txt的内容写符到2.txt文件里面，一行一行读取
FileReader fr = new FileReader("lib/1.txt");
BufferedReader br = new BufferedReader(fr);
FileWriter fw = new FileWriter("lib/2.txt");
BufferedWriter bw = new BufferedWriter(fw);
//可以缩写如下：
BufferedReader br = new BufferedReader(new FileReader("lib/1.txt"));
BufferedWriter bw = new BufferedWriter(new FileWriter("lib/2.txt"));
String str;
while ((str = br.readLine()) != null) {
bw.write(str);
bw.write("\r\n"); //windows情况下用这个
//bw.newLine(); //Linux系统情况下用这个
}
//释放资源
br.close();
bw.close();
22.20字节流是针对图片等其他文件类型的
//13.以下是字节流是针对图片等其他文件类型的
//字节缓冲流，图片1.jpg复制一张2.jpg
//创建字节输入流
FileInputStream fis = new FileInputStream("lib/1.jpg");
//创建字节输出流
FileOutputStream fos = new FileOutputStream("lib/2.jpg");
int len;
while ((len = fis.read()) != -1) {
fos.write(len);
}
//释放资源
fis.close();
fos.close();
//以下是字节流是针对图片等其他文件类型的FileInputStream，FileOutputStream
//字节缓冲流，图片1.jpg复制一张2.jpg，按字节数组读取
FileInputStream fis = new FileInputStream("lib/1.jpg");
FileOutputStream fos = new FileOutputStream("lib/2.jpg");
byte[] bys = new byte[1024];
int len;
while ((len = fis.read(bys)) != -1) {
fos.write(bys,0,len);
}
//释放资源
fis.close();
fos.close();
//字节缓冲流拷贝文件BufferedInputStream，BufferedOutputStream
FileInputStream fis = new FileInputStream("lib/1.jpg");
BufferedInputStream bis = new BufferedInputStream(fis);
FileOutputStream fos = new FileOutputStream("lib/2.jpg");
BufferedOutputStream bos = new BufferedOutputStream(fos);
/**
以后可以用下面的简写方式
BufferedInputStream bis = new BufferedInputStream(new FileInputStream("lib/1.jpg"));
BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("lib/2.jpg"));
*/
int len;
while ((len = bis.read()) != -1) {
bos.write(len);
}
bis.close();
bos.close();
22.21 编码方式IO流
//编码方式IO流
@Test
public void test3(){
//以GBK编码方式往文件1.txt写入字符串
OutputStreamWriter fos = new OutputStreamWriter(new FileOutputStream("D:\\project\\src\\test\\java\\com\\qy\\spring5\\testdemo\\1.txt"),"GBK");
fos.write("中国");
//释放资源
fos.close();
//以GBK编码方式读取1.txt文件的编码内容
InputStreamReader fis = new InputStreamReader(new FileInputStream("D:\\project\\src\\test\\java\\com\\qy\\spring5\\testdemo\\1.txt"), "GBK");
int ch;
while ((ch=fis.read())!=-1){
System.out.println((char)ch); // 输出:中 国
}
//释放资源
fis.close();
}
22.22 将ArrayList集合里面的内容IO流写入文件
//1.将ArrayList集合里面的内容IO流写入文件
@Test
public void test3() throws IOException {
//1.创建Arrylist集合对象
ArrayList<String> arry = new ArrayList<String>();
//2.将字符串添加到集合中
arry.add("java");
arry.add("ni");
arry.add("hao");
//创建字符输出流对象
BufferedWriter bw = new BufferedWriter(new FileWriter("D:\\project\\src\\test\\java\\com\\qy\\spring5\\testdemo\\1.txt"));
//3.遍历集合
for (String s : arry) {
//4.将集合写入文件
bw.write(s);
//5.换行
bw.newLine();
//6.刷新
bw.flush();
}
//释放资源
bw.close();
}
//2.将ArrayList集合里面的内容按特定格式IO流写入文件
@DATA
public class Student {
private String id;
private String name;
private String age;
private String di;
}
@Test
public void test6() throws IOException {
/**
* 输出结果格式如下：
* 0001，刘德华，56，香港
* 0002，古天乐，48，澳门
* 0003，刘亦菲，36，新疆
* 0004，ligang，56，香港
*/
//1.创建Arrylist集合对象
ArrayList<Student> arry = new ArrayList<Student>();
Student stu1 = new Student("0001","刘德华","56","香港");
Student stu2 = new Student("0002","古天乐","48","澳门");
Student stu3 = new Student("0003","刘亦菲","36","新疆");
Student stu4 = new Student("0004","ligang","56","香港");
//2.将字符串添加到集合中
arry.add(stu1);
arry.add(stu2);
arry.add(stu3);
arry.add(stu4);
BufferedWriter bw = new BufferedWriter(new FileWriter("D:\\project\\src\\test\\java\\com\\qy\\spring5\\testdemo\\1.txt"));
//3.字符串拼接功能，将加入进去的字符串按要求输出
for (Student s : arry) {
StringBuilder sb = new StringBuilder();
sb.append(s.getId()+",").append(s.getName()+",").append(s.getAge()+",").append(s.getDi());
bw.write(sb.toString() ); //将sb1的StringBuilder类型转换成字符串String类型
bw.newLine(); //下一行
bw.flush(); //刷新
}
//关闭资源
bw.close();
}
//3.将文件中的内容IO流写入集合
@Test
public void test5() throws IOException {
//创建字节缓冲输入流对象
BufferedReader br = new BufferedReader(new FileReader("D:\\project\\src\\test\\java\\com\\qy\\spring5\\testdemo\\1.txt"));
//创建集合对象
ArrayList<String> arry = new ArrayList<>();
//读取数据，写入集合
String str;
while ((str = br.readLine()) != null) {
arry.add(str);
}
//释放资源
br.close();
//遍历集合
for (String s : arry) {
System.out.println(s); //输出：java ni hao
}
}
//1.定义一个Student类
@Data
public class Student {
private String name;
private int chinese;
private int math;
private int english;
public int getSum() {
return this.chinese+this.math+this.english;
}
}
//2.根据输入的5个学生信息，根据总分从高到低排序，然后根据语文，数学，姓名排序
/**
* 输出结果：
* 胡启行,100,100,100=300
* 光绪,96,84,88=268
* 戚继光,89,96,69=254
* 乾隆,77,86,86=249
* 李刚,55,66,100=221
*/
public static void main(String[] args) throws IOException {
//1.创建TreeSet集合,通过比较器进行排序
TreeSet<Student> ts = new TreeSet<Student>(new Comparator<Student>() {
@Override
public int compare(Student s1, Student s2) {
//主要条件成绩总分从高到低
int num = s2.getSum() - s1.getSum();
//次要条件，根据语文成绩，数学成绩，姓名排序
int num2 = num == 0 ? s1.getChinese() - s2.getChinese() : num;
int num3 = num2 == 0 ? s1.getMath() - s2.getMath() : num2;
int num4 = num3 == 0 ? s1.getName().compareTo(s2.getName()): num3;
return num4;
}
});
//2.输入5个学生的信息
for (int i = 0; i < 5; i++) {
Scanner sc = new Scanner(System.in);
System.out.println("请输入第" + (i + 1) + "个学生信息：");
System.out.println("姓名：");
String name = sc.nextLine();
System.out.println("语文成绩：");
int chinese = sc.nextInt();
System.out.println("数学成绩：");
int math = sc.nextInt();
System.out.println("英语成绩：");
int english = sc.nextInt();
//3.创建Student类对象
Student stu = new Student();
//4.将键盘录入的值设置成学生信息值
stu.setName(name);
stu.setChinese(chinese);
stu.setEnglish(english);
stu.setMath(math);
//5.将Student对象信息添加到TreeSet集合里面
ts.add(stu);
}
//6.创建字符输出流对象
BufferedWriter bw = new BufferedWriter(new FileWriter("D:\\project\\src\\test\\java\\com\\qy\\spring5\\testdemo\\1.txt"));
//7.遍历集合
for (Student s : ts) {
StringBuilder sb = new StringBuilder();
sb.append(s.getName() + ",").append(s.getMath() + ",").append(s.getEnglish() + ",").append(s.getChinese()+ "=").append(s.getMath()+s.getEnglish()+s.getChinese());
bw.write(sb.toString()); //将sb1的StringBuilder类型转换成字符串String类型
bw.newLine(); //下一行
bw.flush(); //刷新
}
//8.关闭资源
bw.close();
}
22.23 字节打印流：往文件里my.txt里面写入
//1.字节打印流：往文件里my.txt里面写入
@Test
public void test9() throws FileNotFoundException {
//使用打印流，打印流只管写入数据不读取数据，创建打印流对象
PrintStream ps = new PrintStream("D:\\project\\src\\test\\resources\\my.txt");
//写入数据97
ps.write(97); //my.txt文件里写入了一个字符:a
//换行
ps.println();
ps.print(97); //my.txt文件里写入了一个字符:97 中间如果不换行的话就输出：a97
/**
ps.println(97);
ps.println(98);
可以输出和上面同样的效果
*/
//关闭资源
ps.close();
}
//2.字符打印流：往文件里my.txt里面写入
@Test
public void test9() throws FileNotFoundException {
//使用字符打印流，打印流只管写入数据不读取数据，创建打印流对象
PrintWriter pw = new PrintWriter("D:\\project\\src\\test\\resources\\my.txt");
//写入数据
pw.write("中国");
//更新
pw.flush();
pw.write("\r\n"); //换行 最后输出结果 中国 你好
pw.write("你好");
//更新
pw.flush();
/**
这个可以达到上面同样的效果，换行输出 你好 中国
pw.println("你好");
pw.flush();
pw.println("中国");
pw.flush();
*/
//关闭资源
pw.close();
}
//常用的写入方法，下面不用写更新语句了，设置为true后，会自动更新
@Test
public void test9() throws IOException {
//使用字符打印流，打印流只管写入数据不读取数据，创建打印流对象
PrintWriter pw = new PrintWriter(new FileWriter("D:\\project\\src\\test\\resources\\my.txt"),true);
pw.println("你好");
pw.println("中国");
pw.println("haha");
//关闭资源
pw.close();
}
//复制TestDemo2.java文件内容到my.java文件内容
@Test
public void test9() throws IOException {
//根据数据源创建字符输入流对象
BufferedReader br = new BufferedReader(new FileReader("D:\\project\\src\\test\\java\\com\\qy\\spring5\\testdemo\\TestDemo2.java"));
//根据目的地创建字符输出流对象
PrintWriter pw = new PrintWriter(new FileWriter("D:\\project\\src\\test\\resources\\my.java"),true);
String str;
while ((str = br.readLine()) != null) {
pw.println(str);
}
//释放资源
br.close();
pw.close();
}
23.反射
23.1获取Class对象
//获取Class对象
//方式一：
Student stu = new Student();
Class<? extends Student> clazz1 = stu.getClass();
System.out.println(clazz1); //输出 class Student
//方式二：
Class<Student> clazz2 = Student.class;
System.out.println(clazz2); //输出 class Student
//方式三：
Class<?> clazz3 = Class.forName("cn.itcast.demo1.Student");
System.out.println(clazz3); //输出 class Student
23.2Student类
//Student类：
public class Student {
//成员变量
public String name;
private int age;
//公共的无参构造方法
public Student() {
}
//公共的带参构造方法
public Student(String name) {
System.out.println("您录入的name值："+name);
}
//私有的带参构造方法
public Student(int age) {
System.out.println("您录入的age值是："+age);
}
//公共的空参方法
public void show1() {
System.out.println("我是公共的空参方法");
}
//公共的带参构造方法
public void show2(int a) {
System.out.println("我是公共的带参方法，您传入的 a值是:" + a);
}
//私有的带参构造方法
private int show3(int a, int b) {
System.out.println("我是私有的带参方法");
return a + b;
}
}
23.3反射类
//反射类
import java.lang.reflect.Constructor;
public class reflection {
public static void main(String[] args) throws Exception {
//1.获取Class对象
Class clazz = Class.forName("cn.itcast.demo2.Student");
//根据上面获取的字节码文件对象，获取指定的构造器对象
//2.获取公共的无参构造
Constructor con1= clazz.getConstructor();
System.out.println(con1); //输出 public cn.itcast.demo2.Student()
//3.获取公共的有参构造getConstructor
Constructor con2 = clazz.getConstructor(String.class);
System.out.println(con2); //输出 public cn.itcast.demo2.Student(java.lang.String)
//4.获取私有的有参构造,getDeclaredConstructor
Constructor con3 = clazz.getDeclaredConstructor(int.class);
System.out.println(con3); //输出 public cn.itcast.demo2.Student(int)
//5.获取Student类所有的公共的构造函数getConstructors
Constructor[] cons = clazz.getConstructors();
for (Constructor con : cons) {
System.out.println(con);
}
/**
*
* 输出：
* public cn.itcast.demo2.Student()
* public cn.itcast.demo2.Student(java.lang.String)
*/
//6.获取构造器的名字，看他是哪个类的构造
String name = con2.getName();
System.out.println(name); //输出 cn.itcast.demo2.Student
//7.根据构造器对象和参数，创建对应的Student对象
Student stu = (Student)con2.newInstance("张三"); //将object类强制转换成Student类
System.out.println(stu);
/**
* 输出：
* 您录入的name值：张三
* cn.itcast.demo2.Student@2f4d3709
*/
23.4获取空参方法，构造器对象和参数
//获取空参方法show1
//1.获取Class对象
Class clazz = Class.forName("cn.itcast.demo2.Student");
//2.获取公共的无参构造
Constructor con1= clazz.getConstructor();
//3.根据构造器对象和参数，创建对应的Student对象
Student stu1 = (Student)con1.newInstance();
System.out.println(stu1); //输出 cn.itcast.demo2.Student@7ef20235
//4.调用公共的空参方法
Method method1 = clazz.getMethod("show1");
//5.打印方法对象
System.out.println(method1); //输出 public void cn.itcast.demo2.Student.show1()
//5.1打印方法名
System.out.println(method1.getName()); //输出 show1
//5.2调用此方法
method1.invoke(stu1); //输出 我是公共的空参方法
23.5获取带参方法
//获取带参方法show2
//1.获取Class对象
Class clazz = Class.forName("cn.itcast.demo2.Student");
//2.获取公共的无参构造
Constructor con1= clazz.getConstructor();
//3.根据构造器对象和参数，创建对应的Student对象
Student stu1 = (Student)con1.newInstance();
System.out.println(stu1); //输出 cn.itcast.demo2.Student@7ef20235
//4.调用公共的有参方法
Method method1 = clazz.getMethod("show2",int.class);
//5.打印方法对象
System.out.println(method1); //输出 public void cn.itcast.demo2.Student.show2(int)
//5.1打印方法名
System.out.println(method1.getName()); //输出 show2
//5.2调用此方法
method1.invoke(stu1,100); //输出 我是公共的带参方法，您传入的 a值是:100
23.6获取私有的带参的方法
//获取私有的带参的方法show3
//获取带参方法show3
//1.获取Class对象
Class clazz = Class.forName("cn.itcast.demo2.Student");
//2.获取私有的有参构造
Constructor con1= clazz.getDeclaredConstructor();
//3.根据构造器对象和参数，创建对应的Student对象
Student stu1 = (Student)con1.newInstance();
System.out.println(stu1); //输出 cn.itcast.demo2.Student@7ef20235
//4.调用私有的有参方法
Method method3 =clazz.getDeclaredMethod("show3",int.class,int.class);
//4.1开启暴力反射，不管是不是私有的都拿过来
method3.setAccessible(true);
//5.打印方法对象
System.out.println(method3); //输出 private int cn.itcast.demo2.Student.show3(int,int)
//5.1打印方法名
System.out.println(method3.getName()); //输出 show3
//5.2调用此方法
int sum = (int) method3.invoke(stu1, 100, 200);//输出 我是私有的带参方法
System.out.println("您录入的两个数和是："+sum); //输出 您录入的两个数和是：300
}
}
23.7反射方式获取Student类getter,setter成员方法
//反射方式获取Student类getter,setter成员方法
public class Student {
//成员变量
private String name;
//空参构造
public Student() {
}
//带参构造
public Student(String name) {
this.name = name;
}
//getter和setter
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
//toString方法，用来打印对象的各属性值
@Override
public String toString() {
return "Student{" +
"name='" + name + '\'' +
'}';
}
}
23.8反射获取
//反射获取
import java.lang.reflect.Constructor;
import java.lang.reflect.Method;
//1.获取Class对象
Class clazz = Class.forName("cn.itcast.demo2.Student");
//2.获取公共的无参构造
Constructor con1= clazz.getConstructor();
//3.根据构造器对象和参数，创建对应的Student对象
Student stu1 = (Student)con1.newInstance();
//4.获取指定的setName()方法,给Student对象设置值
Method method1 = clazz.getMethod("setName", String.class);
//4.1调用此方法
method1.invoke(stu1,"张无忌");
//5.打印学生对象
System.out.println(stu1); //输出 Student{name='张无忌'}
23.8反射获取成员变量
//反射方式获取成员变量
public class Student {
//公有属性
public String name;
//私有属性
private int age;
//toString方法，用来打印对象的各属性值
@Override
public String toString() {
return "Student{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
}
public class reflection {
public static void main(String[] args) throws Exception {
//1.获取Class对象
Class clazz = Class.forName("cn.itcast.demo2.Student");
//2.获取公共的无参构造
Constructor con1= clazz.getConstructor();
//3.根据构造器对象和参数，创建对应的Student对象
Student stu1 = (Student)con1.newInstance();
//4.设置学生对象的各个属性值
//4.1设置姓名
Field field1 = clazz.getField("name");
field1.set(stu1, "张无忌");
//4.2设置私有年龄
Field field2 = clazz.getDeclaredField("age");
//需要开启暴力反射
field2.setAccessible(true);
field2.set(stu1, 36);
//5.打印学生对象
System.out.println(stu1); //输出 Student{name='张无忌', age=36}
}
}
24.创建泛型类，泛型接口
//1.创建泛型类Generic
public class Generic<T> {
private T t;
public T getT() {
return t;
}
public void setT(T t) {
this.t = t;
}
@Test
public void Test() {
//创建保存String类型数据的实例对象
Generic<String> str = new Generic<>();
str.setT("李刚");
System.out.println(str.getT()); //输出：李刚
//创建保存Integer类型数据的实例对象
Generic<Integer> in = new Generic<>();
in.setT(20);
System.out.println(in.getT()); //输出：20
}
//2.泛型类
public class Show<T> {
//创建泛型参数的方法
public void showname(T t){
System.out.println(t);
}
}
@Test
public void test(){
//存入String对象
Show<String> str = new Show<String>();
str.showname("林青霞"); //输出：林青霞
//存入object对象爱
Show<Object> obj = new Show<Object>();
obj.showname("zhangsan"); //输出：zhangsan
}
//3.创建泛型接口
public interface Genetic<T> {
void show(T t);
}
//创建泛型实现类继承泛型接口
public class GeniticImpl<T> implements Genetic<T>{
@Override
public void show(T t) {
System.out.println(t);
}
}
@Test
public void test(){
//创建泛型实现类的对象
GeniticImpl<String> str = new GeniticImpl<String>();
str.show("林青霞"); //输出：林青霞
}
25.类型通配符
//类型通配符<?>
List<?> list1 = new ArrayList<Object>();
List<?> list2 = new ArrayList<String>();
//类型通配符上限上限是Number类型
List<? extends Number> list3 = new ArrayList<Number>();
List<? extends Number> list4 = new ArrayList<Integer>();
//类型通配符下限是Number类型
List<? super Number> list5 = new ArrayList<Object>();
List<? super Number> list6 = new ArrayList<Number>();
26.创建参数可变函数
public class NiHao {
//创建参数可变函数
public static int sum(int b,int...a){
int sum = 0;
//可变参数是一个素组，所以可以遍历获取数值
for (int i : a) {
sum+=i;
}
//返回所有参数的和，可变参数必须要放在不变参数的后面才不会报错
return sum+b;
}
}
@Test
public void test1(){
int sum1 = NiHao.sum(5, 20, 30);
System.out.println(sum1); //输出：55
int sum2 = NiHao.sum(5, 20, 30, 40, 50);
System.out.println(sum2); //输出：145
27.序列化和反序列化
//这个被transient修饰的属性不可以被序列化：private transient int age;
@Data
@NoArgsConstructor
@AllArgsConstructor
//只有继承Serializable接口，对象才可以被序列化，且不需要重写任何方法
public class Student implements Serializable {
//必须要加上这一句序列化就不会出错
private static final long serialVersionUID = 42L;
private String name;
private int age;
}
@Test
public void test1() throws IOException, ClassNotFoundException {
//1.下面执行对象序列化结果是一个读不懂的文件
//创建一个写入指定的outputstream的ObjectOutputStream对象
ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("D:\\project\\src\\test\\java\\com\\qy\\spring5\\testdemo\\1.txt"));
//创建Student对象
Student stu = new Student("林青霞",30);
//将指定的对象写入ObjectOutputStream
oos.writeObject(stu);
//释放资源
oos.close();
//2.下面执行对象反序列化来读取这个读不懂的文件
ObjectInputStream ois= new ObjectInputStream(new FileInputStream("D:\\project\\src\\test\\java\\com\\qy\\spring5\\testdemo\\1.txt"));
//读取反序列化对象
Object obj = ois.readObject();
//转换成Student对象
Student st = (Student) obj;
//获取属性
System.out.println(st.getName()+","+st.getAge()); //输出结果：林青霞,30
28网络通信
28.1获取计算机名，IP地址
//获取计算机名为sc-202103112315的IP的IP地址,创建对象可以是下面两种方式中的任意一种
//InetAddress address = InetAddress.getByName("sc-202103112315");
InetAddress address = InetAddress.getByName("192.168.232.1");
System.out.println(address); //输出 /192.168.232.1
String hostName = address.getHostName();
System.out.println(hostName); //输出主机名 sc-202103112315
String hostAddress = address.getHostAddress();
System.out.println(hostAddress); //输出IP地址 192.168.232.1
//如果java运行过程中提示：java Address already in use: bind 表明端口已经被占用，需要重新跟换端口测试，即可
/**
端口设置在1024到65535之间即可,
UDP协议：音频，视频，普通数据传输，不需要连接
TCP协议：3次握手，可靠连接以后才传输数据
*/
28.1UDP通信
UDP发送端：
//UDP协议传输，创建发送端的socket对象
DatagramSocket ds = new DatagramSocket();
//要发的数据包内容
byte[] bys = "你好，中国，我来了哦".getBytes();
//创建网络对象
InetAddress address = InetAddress.getByName("SC-202103112315");
//定义应用程序的端口
int port = 10086;
//创建发送数据包
DatagramPacket dp = new DatagramPacket(bys, bys.length, address, port);
//调用发送端socket发送数据
ds.send(dp);
//关闭发送端
ds.close();
/**
可以简写如下：
//UDP协议传输，创建发送端的socket对象
DatagramSocket ds = new DatagramSocket();
//要发的数据包内容
byte[] bys = "你好，中国，我来了哦".getBytes();
//创建发送数据包
DatagramPacket dp = new DatagramPacket(bys, bys.length, InetAddress.getByName("SC-202103112315"), 10086);
//调用发送端socket发送数据
ds.send(dp);
//关闭发送端
ds.close();
*/
UDP接收端：
//UDP协议传输，创建接收端的socket对象
DatagramSocket ds = new DatagramSocket(10086);
//定义接收数据的空字符数组
byte[] bys = new byte[1024];
//创建接收数据包
DatagramPacket dp = new DatagramPacket(bys, bys.length);
//接收数据
ds.receive(dp);
//将数据装入字符数组
byte[] datas = dp.getData();
//转成字符串
String s = new String(datas);
System.out.println("接收的数据是：" + s);
//关闭接收端
ds.close();
/**
接收端可以简写如下
//UDP协议传输，创建接收端的socket对象
DatagramSocket ds = new DatagramSocket(10086);
//定义接收数据的空字符数组
byte[] bys = new byte[1024];
//创建接收数据包
DatagramPacket dp = new DatagramPacket(bys, bys.length);
//接收数据
ds.receive(dp);
//输出数据
System.out.println("接收的数据是：" + new String(dp.getData()));
//关闭接收端
ds.close();
*/
/**
UDP实现发送端：键盘录入，发送886退出
UDP接收端：一直接收
*/
//UDP发送端：
public class send1 {
public static void main(String[] args) throws IOException {
while (true) {
//创建键盘录入对象
Scanner sc = new Scanner(System.in);
System.out.println("请输入数据：");
//接收数据
String s = sc.nextLine();
if (s.equals("886")){
System.exit(0);
}else {
send(s);
}
}
}
public static void send(String s) throws IOException {
//UDP协议传输，创建发送端的socket对象
DatagramSocket ds = new DatagramSocket();
//要发的数据包内容
byte[] bys = s.getBytes();
//创建网络对象
InetAddress address = InetAddress.getByName("SC-202103112315");
//定义应用程序的端口
int port = 10086;
//创建发送数据包
DatagramPacket dp = new DatagramPacket(bys, bys.length, address, port);
//调用发送端socket发送数据
ds.send(dp);
//关闭发送端
ds.close();
}
}
//UDP接收端：
public class re1 {
public static void main(String[] args) throws IOException {
//UDP协议传输，创建接收端的socket对象
DatagramSocket ds = new DatagramSocket(10086);
while (true) {
//定义接收数据的空字符数组
byte[] bys = new byte[1024];
//创建接收数据包
DatagramPacket dp = new DatagramPacket(bys, bys.length);
//接收数据
ds.receive(dp);
//将数据装入字符数组
byte[] datas = dp.getData();
//转成字符串
String s = new String(datas);
System.out.println("接收的数据是：" + s);
}
}
}
28.2TCP协议通信
//TCP协议发送端：
public class Send2 {
public static void main(String[] args) throws IOException {
//创建客户端的Socket对象
Socket s = new Socket("192.168.232.1", 10086);
//获取输出流
OutputStream os = s.getOutputStream();
//写数据
os.write("中国中国我爱你".getBytes());
//接收服务器的反馈
InputStream is = s.getInputStream();
byte[] bys = new byte[1024];
int len = is.read(bys);
String data = new String(bys, 0, len);
System.out.println("客户端"+data);
//释放资源
s.close();
}
}
//TCP协议接收端：
public class re2 {
public static void main(String[] args) throws IOException {
//创建服务器的ServerSocket对象
ServerSocket ss = new ServerSocket(10086);
//侦听要连接到此套接字并接收它
Socket s = ss.accept();
//获取收入流
InputStream is = s.getInputStream();
byte[] bys = new byte[1024];
//读取数据
int len = is.read(bys);
//数据转成字符串
String data = new String(bys, 0, len);
System.out.println("服务器："+data);
//给出反馈
OutputStream os = s.getOutputStream();
os.write("数据已经收到了".getBytes());
//关闭资源
s.close();
ss.close();
}
}
/**
数据来自键盘输入，客户端输入“886”就断开连接，服务器端接收数据，并把接收到的数据写入到2.txt文件中
*/
//TCP协议服务器端部分
//创建服务器的ServerSocket对象
ServerSocket ss = new ServerSocket(10086);
//监听客户端的连接，返回一个对应的socket对象
Socket s = ss.accept();
//获取输入流对象，接收数据
BufferedReader br = new BufferedReader(new InputStreamReader(s.getInputStream()));
//把数据写入文本文件
BufferedWriter bw = new BufferedWriter(new FileWriter("Test\\2.txt")); //Test是模块名
String line;
while ((line = br.readLine()) != null) {
System.out.println(line); //打印接收到的内容
bw.write(line); //写入文件到2.txt
bw.newLine(); //换行
bw.flush(); //刷新
}
//释放资源
ss.close();
bw.close();
//TCP协议客户端部分
//创建客户端的Socket对象，TCP发送都是客户端向服务器端先发送数据，连接时，先开启服务器，然后开启客户端，不然连接不上会报错
Socket s = new Socket("192.168.232.1", 10086);
//1.下面两种客户端发送数据的方式选择一种
//1.1接收来自及键盘输入的数据
BufferedReader bis = new BufferedReader(new InputStreamReader(System.in));
//1.2如果客户端数据不是来自键盘输入而是来自文本文件2.txt内容如下：
BufferedReader bis = new BufferedReader(new FileReader("Test\\2.txt"));
//封装数据输出流对象
BufferedWriter bos = new BufferedWriter(new OutputStreamWriter(s.getOutputStream()));
String line;
while ((line = bis.readLine()) != null) { //来自键盘输入的数据如果不为空
if ("886".equals(line)) { //如果输出886，就退出
break;
}
bos.write(line); //输出流对象写出字符串
bos.newLine(); //输出流对象换行
bos.flush(); //刷新
}
//释放资源
s.close();
//客户端：数据来自文本文件，接收服务器反馈
//服务器端：接收到的数据写入文本文件，给出反馈
//TCP协议客户端：
Socket s = new Socket("192.168.232.1", 12086);
//1.下面两种客户端发送数据的方式选择一种
//1.1接收来自及键盘输入的数据
//BufferedReader bis = new BufferedReader(new InputStreamReader(System.in));
//1.2如果客户端数据不是来自键盘输入而是来自文本文件2.txt内容如下：
BufferedReader bis = new BufferedReader(new FileReader("Test\\1.txt"));
//封装数据输出流对象
BufferedWriter bos = new BufferedWriter(new OutputStreamWriter(s.getOutputStream()));
String line;
while ((line = bis.readLine()) != null) { //来自键盘输入的数据如果不为空
bos.write(line); //输出流对象写出字符串
bos.newLine(); //输出流对象换行
bos.flush(); //刷新
}
// //自定义结束标记（一般不用）
// bos.write("886");
// bos.newLine();
// bos.flush();
//用函数定义结束标记
s.shutdownOutput();
//接收反馈
BufferedReader brclient = new BufferedReader(new InputStreamReader(s.getInputStream()));
String data = brclient.readLine();
System.out.println("服务器反馈:"+data);
//释放资源
s.close();
bis.close();
//TCP协议服务器端：
//创建服务器的ServerSocket对象
ServerSocket ss = new ServerSocket(12086);
//监听客户端的连接，返回一个对应的socket对象
Socket s = ss.accept();
//获取输入流对象，接收数据
BufferedReader br = new BufferedReader(new InputStreamReader(s.getInputStream()));
//把数据写入文本文件
BufferedWriter bw = new BufferedWriter(new FileWriter("Test\\2.txt")); //Test是模块名
String line;
while ((line = br.readLine()) != null) { //等待读取
// if("886".equals(line)){ //886接收连接标志判断
// break;
// }
System.out.println(line); //打印接收到的内容
bw.write(line); //写入文件到2.txt
bw.newLine(); //换行
bw.flush(); //刷新
}
//给出反馈
BufferedWriter bwserver = new BufferedWriter(new OutputStreamWriter(s.getOutputStream()));
bwserver.write("上传成功");
bwserver.newLine(); //换行
bwserver.flush(); //刷新
//释放资源
ss.close();
bw.close();
/**
TCP协议客户端：数据来自文本文件，接收服务器反馈，
TCP协议客户端:接收到的数据写入文本文件，给出反馈，为每一个客户端开起一个线程
*/
//客户端：
Socket s = new Socket("192.168.232.1", 12086);
//1.下面两种客户端发送数据的方式选择一种
//1.1接收来自及键盘输入的数据
//BufferedReader bis = new BufferedReader(new InputStreamReader(System.in));
//1.2如果客户端数据不是来自键盘输入而是来自文本文件2.txt内容如下：
BufferedReader bis = new BufferedReader(new FileReader("Test\\1.txt"));
//封装数据输出流对象
BufferedWriter bos = new BufferedWriter(new OutputStreamWriter(s.getOutputStream()));
String line;
while ((line = bis.readLine()) != null) { //来自键盘输入的数据如果不为空
bos.write(line); //输出流对象写出字符串
bos.newLine(); //输出流对象换行
bos.flush(); //刷新
}
//用函数定义结束标记
s.shutdownOutput();
//接收反馈
BufferedReader brclient = new BufferedReader(new InputStreamReader(s.getInputStream()));
String data = brclient.readLine();
System.out.println("服务器反馈:" + data);
//释放资源
s.close();
bis.close();
//服务器端：
//TCP协议服务器端：
//创建服务器的ServerSocket对象
ServerSocket ss = new ServerSocket(12086);
while(true) {
//监听客户端的连接，返回一个对应的socket对象
Socket s = ss.accept();
//为每一个客户端开启一个线程
new Thread(new ServerThead(s)).start();
}
//ServerThead.java:线程类
//前面new ServerThead(s)报错的时候
//alt+回车键，生成ServerTgead类一定要继承Runnable才可以
public class ServerThead implements Runnable {
private Socket s;
public ServerThead(Socket s) {
//这一句要手写
this.s = s;
}
@Override
public void run() {
try {
//获取输入流对象，接收数据
BufferedReader br = new BufferedReader(new InputStreamReader(s.getInputStream()));
//解决名称冲突问题，每重启一此客户端和服务器，都会写入copy[0].txt,copy[1].txt,这样不同的名称文件
int count = 0;
File file = new File("Test\\copy[" + count + "].txt");
while (file.exists()) {
count++;
file = new File("Test\\copy[" + count + "].txt");
}
//把数据写入文本文件
BufferedWriter bw = new BufferedWriter(new FileWriter(file)); //Test是模块名
String line;
while ((line = br.readLine()) != null) { //等待读取
System.out.println(line); //打印接收到的内容
bw.write(line); //写入文件到2.txt
bw.newLine(); //换行
bw.flush(); //刷新</try>
}
//给出反馈
BufferedWriter bwserver = new BufferedWriter(new OutputStreamWriter(s.getOutputStream()));
bwserver.write("上传成功");
bwserver.newLine(); //换行
bwserver.flush(); //刷新
//释放资源
bw.close();
}catch(IOException e){
}
}
}
29.定义接口并且实现接口
//1.定义一个接口Eatable
public interface Eatable {
void eat();
}
//2.定义一个接口实现类EatableImpl继承Eatable
public class EatableImpl implements Eatable{
@Override
public void eat() {
System.out.println("一天一个苹果，医生远离我");
}
}
//3.1定义一个测试类EatableTest，这个测试类的执行结果是实现类里面的输出结果：一天一个苹果，医生远离我
//这里就需要接口，实现接口的类，测试类
public class EatableTest {
public static void main(String[] args) {
//多态的方式接口，new一个实现类对象
Eatable e = new EatableImpl();
//调用自定义函数
useEatable(e);
}
//定义一个方法调用实现类里的eat()方法，把实现类的对象作为参数传入
private static void useEatable(Eatable e){
//通过实现类对象.的方式调用eat方法
e.eat();
}
}
//3.2定义一个测试类EatableTest，这个测试类的执行结果是实现类里面的输出结果：哈哈哈哈哈哈
//这里就只需要接口和测试类就可以，不需要实现接口的类了
public class EatableTest {
public static void main(String[] args) {
//匿名内部类
useEatable(new Eatable() {
@Override
public void eat() {
System.out.println("哈哈哈哈哈哈");
}
});
}
//定义一个方法调用实现类里的eat()方法，把实现类的对象作为参数传入
private static void useEatable(Eatable e){
//通过实现类对象.的方式调用eat方法
e.eat();
}
}
//3.3定义一个测试类EatableTest，通过lambda表达式输出，输出结果是：你个小鬼
//这里就只需要接口和测试类就可以，不需要实现接口的类了
public class EatableTest {
public static void main(String[] args) {
// lambda表达式输出
useEatable(()->{
System.out.println("你个小鬼");
});
}
//定义一个方法调用实现类里的eat()方法，把实现类的对象作为参数传入
private static void useEatable(Eatable e){
//通过实现类对象.的方式调用eat方法
e.eat();
}
}
//创建一个接口
public interface Flyable {
void fly(String s);
}
//**
创建一个测试类，输出结果是：
晴空万里无云
飞机自驾游
适合飞行
*/
public class FlyableTest {
public static void main(String[] args) {
//通过匿名内部类实现
useFlyable(new Flyable() {
@Override
public void fly(String s) {
System.out.println(s);
System.out.println("飞机自驾游");
}
});
//通过lambda表达式实现
useFlyable((String s)->{
System.out.println("适合飞行");
});
}
private static void useFlyable(Flyable f){
f.fly("晴空万里无云");
}
}
//当接口有且仅有一个方法的时候才可以使用lambda表达式，
// 参数类型可以省略如下：
useAddable(( x, y)->{
return x*y;
});
//当且仅当只有一个参数的时候可以入如下写：
useAddable(x->{
System.out.println(s);
});
//当只有一个参数和只有一个语句的时候可以如下写：
useFlyable(s->System.out.println("你好呀"));
30.通过idea软件运行gitte上面的项目
31.maven和git的使用
31.1Maven的安装
31.2Maven的安装配置
31.3Maven的配置本地仓库和阿里云镜像
31.3.1Maven的命令格式和常用命令
31.4在Idea中配置Maven
31.5在Idea中创建web项目
31.5.1在Idea中创建web项目部署的插件
31.5.2Jetty插件
31.5.3Tomacat插件
31.5.4mvn仓库
31.5.5Maven项目环境下构建多模块项目
31.5.6servlet服务器
31.5.7Maven的打包操作
31.5.8添加Profile配置
31.5.9设置资源文件配置
31.5.10通过Maven创建的Web工程
31.6在Idea中使用Git
31.6.1在Idea中常用快捷键
31.6.2在Idea中添加GitHub账号
扫一扫
19万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
