目录
第十三章
第一题
案例：在子线程中输出1-100之间的偶数，主线程输出1-100之间的奇数。
效果如下：
package com.atguigu.test01;
public class Test01 {
public static void main(String[] args) {
new Thread("子线程"){
public void run(){
for (int i = 0; i <= 100; i+=2) {
System.out.println(getName() + "-->" + i);
}
}
}.start();
for (int i = 1; i <= 100; i+=2) {
System.out.println("main主线程 -->" + i);
}
}
}
第二题
案例：创建和启动2个子线程，一个打印1-10之间奇数，一个打印1-10之间偶数。
（1）要求每个线程要么不打印，要么就连续打印5个数，每个数打印间隔500毫秒
（2）但两个线程不要求交替打印。
效果如下：
package com.atguigu.test02;
public class Test02 {
public static void main(String[] args) {
new PrintEven().start();
new PrintOdd().start();
}
}
class PrintEven extends Thread{
private int num = 1;
public void run(){
while(true){
synchronized (Thread.class) {
for (int i = 1; i <= 5; i++) {
num+=2;
System.out.println("偶数线程，第" + i + "个：" + num);
try {
Thread.sleep(500);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
}
}
class PrintOdd extends Thread{
private int num = 2;
public void run(){
while(true){
synchronized (Thread.class) {
for (int i = 1; i <= 5; i++) {
num+=2;
System.out.println("奇数线程，第" + i + "个：" + num);
try {
Thread.sleep(500);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
}
}第三题
案例：创建和启动2个子线程，一个打印奇数，一个打印偶数。
（1）要求实现交替打印。
（2）每个数打印间隔1秒
效果如下：
package com.atguigu.test03;
public class Test03 {
public static void main(String[] args) {
new PrintNumber().start();
new PrintNumber().start();
}
}
class PrintNumber extends Thread{
private static int num;
public void run(){
while(true){
synchronized (PrintNumber.class) {
try {
PrintNumber.class.notify();
Thread.sleep(1000);
System.out.println(getName() + ":" + ++num);
PrintNumber.class.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
}第四题
案例：
1、创建一个银行账户类，
（1）属性：账号，余额，
（2）get/set，
（3）toString()：返回：账户：xxx，余额：xxx
2、创建一个丈夫类
负责往里存钱，每次存款[0,10000)以内不等
3、创建一个妻子类
负责取钱，每次取款[0,10000)以内不等，如果余额不足，要等丈夫存够了才能取
package com.atguigu.test04;
public class Test04 {
public static void main(String[] args) {
Account a = new Account("1122",0);
new Wife(a).start();
new Husband(a).start();
}
}
class Account{
private String id;
private double balance;
public Account(String id, double balance) {
super();
this.id = id;
this.balance = balance;
}
public String getId() {
return id;
}
public void setId(String id) {
this.id = id;
}
public double getBalance() {
return balance;
}
public void setBalance(double balance) {
this.balance = balance;
}
@Override
public String toString() {
return "账户：" + id + ",余额：" + balance ;
}
}
class Wife extends Thread{
private Account account;
public Wife(Account account) {
super();
this.account = account;
}
public void run(){
while(true){
synchronized (Thread.class) {
double money = Math.random() * 10000;
while(money > account.getBalance()){
System.out.println("本次妻子想取钱：" + money +"，但是余额不足，等待...");
try {
Thread.class.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
System.out.println("妻子开始取钱，目前账户状态：" + account);
System.out.println("本次妻子取钱：" + money);
account.setBalance(account.getBalance() - money);
System.out.println("妻子取钱结束，目前账户状态：" + account);
System.out.println();
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
}
class Husband extends Thread{
private Account account;
public Husband(Account account) {
super();
this.account = account;
}
public void run(){
while(true){
synchronized (Thread.class) {
double money = Math.random() * 10000;
System.out.println("丈夫开始存钱，目前账户状态：" + account);
System.out.println("本次丈夫存钱：" + money);
account.setBalance(account.getBalance() + money);
System.out.println("丈夫开始结束，目前账户状态：" + account);
System.out.println();
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
Thread.class.notify();
}
}
}
}第五题
案例：请按要求编写多线程应用程序，模拟多个人通过一个山洞：
1、这个山洞每次只能通过一个人，每个人通过山洞的时间为5秒；
2、随机生成10个人，同时准备过此山洞
3、定义一个变量用于记录通过隧道的人数
4、显示每次通过山洞人的姓名，和通过顺序；
操作步骤描述
1.定义一个隧道类，实现Runnable接口：
1.1 定义一个变量，用来记录通过隧道的人数；
1.2 重写Runnable的run方法；
1.3 定义一个同步方法，模拟每个人通过隧道需要5秒钟：
1.3.1 打印“xx开始通过隧道...”
1.3.2 子线程睡眠5秒钟，模拟每个人通过隧道需要5秒钟；
1.3.3 改变通过的人次；
1.3.4 打印线程名称及其通过隧道的顺序，模拟人通过隧道及其顺序；
1.4 调用通过隧道的方法；
2.定义一个测试类：
2.1.在main方法中创建一个隧道类对象；
2.2.在main方法中，循环创建10个子线程对象，通过构造方法把隧道对象
和线程名（作为人的姓名）传递进去，并开启子线程；
package com.atguigu.test05;
public class Tunnel implements Runnable {
// 1.1 定义一个变量，用来记录通过隧道的人数
private int crossNum = 0;
/*
* 1.2 重写Runnable的run方法
*/
@Override
public void run() {
// 1.4 调用通过隧道的方法
cross();
}
/*
* 1.3 定义一个同步方法，模拟每个人通过隧道需要5秒钟
*/
public synchronized void cross() {
//1.3.1 打印 xx开始通过隧道...
System.out.println(Thread.currentThread().getName() + "开始通过隧道...");
// 1.3.2 子线程睡眠5秒钟，模拟每个人通过隧道需要5秒钟
try {
Thread.sleep(5000);
} catch (InterruptedException e) {
e.printStackTrace();
}
// 1.3.3 改变通过的人次
crossNum++;
// 1.3.4 打印线程名称及其通过隧道的顺序，模拟人通过隧道及其顺序
System.out.println(Thread.currentThread().getName() + "已经通过隧道，TA是第" + crossNum + "通过的！");
}
}
package com.atguigu.test05;
public class Test05 {
public static void main(String[] args) {
// 2.1 在main方法中创建一个隧道类对象
Tunnel tul = new Tunnel();
// 2.2 在main方法中，循环创建10个子线程对象，通过构造方法把隧道对象和// 线程名（作为人的姓名）传递进去，并开启子线程
for (int i = 1; i <= 10; i++) {
Thread t = new Thread(tul, "p" + i);
t.start();
}
}
}
第十四章
第一题
有一个数组a[1000]存放0-999，要求每隔二个数删掉一个数，到末尾时循环至开头，继续运行。求最后一个被删掉的数的原始下标位置。
以8个数为例：
{0,1,2,3,4,5,6,7}：0->1->2（删掉）->3->4->5（删掉）->6->7->0（删掉）。。。
/*
* 有一个数组a[1000]存放0-999，要求每隔二个数删掉一个数，到末尾时循环至开头，继续运行。求最后一个被删掉的数的原始下标位置。
以8个数为例：
{0,1,2,3,4,5,6,7}：0->1->2（删掉）->3->4->5（删掉）->6->7->0（删掉）。。。
*/
public class TestHomework1 {
public static void main(String[] args) throws InterruptedException {
int[] a = new int[1000];
for (int i = 0; i < a.length; i++) {
a[i] = i;
}
int i=0;
int count = 0;
int delNum = 0;//被删掉的数字个数
while(true) {
if(a[i]!=-1) {//被删掉的数不再计入count个数
count++;
}
if(count==3) {//隔两个，第三个删掉
a[i]=-1;//a[i]=-1，表示被删掉的数
count=0;//count重新计数
delNum++;//统计已经被删掉几个了
}
if(delNum==a.length-1) {//留下最后一个结束删除过程
break;
}
if(++i==a.length) {//如果下标右移已经到头了，要从头开始
i=0;
}
}
for (int j = 0; j < a.length; j++) {
if(a[j]!=-1) {
System.out.println("最后一个被删掉的数是：a[j]=" + a[j] + "，它的下标：" + j);
}
}
}
}第二题
public static int binarySearch(int[] intsArray, int des) {
int left = 0;
int right = intsArray.length-1;
int mid = (left + right)/2;
while(left<=right) {
if(intsArray[mid]==des) {
return mid;
}else if(des>intsArray[mid]){
left = mid+1;
}else {
right=mid-1;
}
mid = (left + right)/2;
}
return -1;
}第三题
public static int binarySearch(String[] intsArray, String des) {
int left = 0;
int right = intsArray.length-1;
int mid = (left + right)/2;
while(left<=right) {
if(intsArray[mid].equals(des)) {
return mid;
}else if(des.compareTo(intsArray[mid])>0){//字符串比较大小的方法
left = mid+1;
}else {
right=mid-1;
}
mid = (left + right)/2;
}
return -1;
}第四题
public static void main(String[] args) throws InterruptedException {
System.out.println(Arrays.toString(suShu(10)));
}
public static int[] suShu(int n){
int[] arr = new int[n];
int index=0;
for (int i = 1; i < n; i++) {
boolean flag = true;
for (int j = 2; j < i; j++) {
if(i%j==0) {
flag=false;
break;
}
}
if(flag) {
arr[index++] = i;
}
}
return Arrays.copyOf(arr, index);
}第五题
public static void main(String[] args) throws InterruptedException {
int[] arr = {1,2,3,4,5,6,7};
arr = changPosition(1,5,arr);
System.out.println(Arrays.toString(arr));
}
public static int[] changPosition(int n1,int n2,int[] ii) {
int indexN1=-1;
for (int i = 0; i < ii.length; i++) {
if(ii[i]==n1) {
indexN1 = i;
break;
}
}
int indexN2 = -1;
for (int i = 0; i < ii.length; i++) {
if(ii[i]==n2) {
indexN2 = i;
break;
}
}
System.arraycopy(ii, indexN1+1, ii, indexN1, indexN2-indexN1);
ii[indexN2]=n1;
return ii;
}第六题
import java.util.Arrays;
public class TestHomework6 {
public static void main(String[] args) {
int[] arr = {0,1,2,3,4,5,6,7,8,9};
int m = 10;
for (int i = 0; i < m; i++) {
move(arr);
System.out.println(Arrays.toString(arr));
}
int value = 5;
System.out.println(indexOf(arr, m, value));
}
public static int indexOf(int[] arr,int m, int value) {
while(m>arr.length) {
m = m - arr.length;
}
if(value == arr[0]) {
return 0;
}else if(value > arr[0]) {
return Arrays.binarySearch(arr, 1, m, value);
}else {
return Arrays.binarySearch(arr, m, arr.length, value);
}
}
public static void move(int[] arr) {
int temp = arr[arr.length-1];
System.arraycopy(arr, 0, arr, 1, arr.length-1);
arr[0] = temp;
}
}第十五章
代码编程题
第一题
-
反转键盘录入的字符串。
-
代码实现，参考效果如图所示：
package com.atguigu.test01;
import java.util.Scanner;
public class Test01 {
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
System.out.print("请键盘输入字符串：");
String str = input.next();
StringBuilder s = new StringBuilder(str);
str = s.reverse().toString();
System.out.println("反转后：" + str);
input.close();
}
}
第二题
-
键盘录入QQ号码，验证格式的正确性。
-
必须是5—12位数字。
-
0不能开头。
-
-
代码实现，参考效果如图所示：
package com.atguigu.test02;
import java.util.Scanner;
public class Test02 {
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
System.out.print("请输入qq号码：");
String qq = input.next();
System.out.print("这个qq号是否正确：");
if(qq.matches("[1-9][0-9]{4,11}+")){
System.out.println(true);
}else{
System.out.println(false);
}
input.close();
}
}第三题
-
字符串查找。
-
键盘录入一个大字符串，再录入一个小字符串。
-
统计小字符串在大字符串中出现的次数。
-
-
代码实现，效果如图所示：
package com.atguigu.test03;
import java.util.Scanner;
public class Test03 {
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
System.out.print("请输入大字符串：");
String big = input.next();
System.out.print("请输入小字符串：");
String small = input.next();
int index;
int count = 0;
while((index = big.indexOf(small))!=-1){
big = big.substring(index+small.length());
count++;
}
System.out.println(small + "出现了" +count + "次");
input.close();
}
}
第四题
-
替换某字符串中的某字符串。
-
键盘录入一个srcStr字符串，再录入一个delStr字符串。
-
删除该字srcStr符串中的所有delStr字符串。
-
并且统计delStr字符串在srcStr中出现的次数
-
-
代码实现，部分效果如图所示：
package com.atguigu.test04;
import java.util.Scanner;
public class Test04 {
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
System.out.print("请输入原字符串：");
String src = input.next();
System.out.print("请输入要删除的字符串：");
String del = input.next();
String result = src.replaceAll(del, "");
int count = (src.length() - result.length())/del.length();
System.out.println(del+"共出现了：" + count + "次");
System.out.println("删除" + del + "后字符串：" + result);
input.close();
}
}
第五题
-
生成一个随机100内小数，转换为保留两位小数的字符串，不考虑四舍五入的问题。
-
代码实现，效果如图所示：
package com.atguigu.test05;
public class Test05 {
public static void main(String[] args) {
double num = Math.random() * 100;
System.out.println("随机数为：" +num);
String str = num + "";
str = str.substring(0,str.indexOf(".") + 3);
System.out.println("截取小数点后两位后为：" + str);
}
}第六题
-
筛选字符串。
-
定义数组，存入多个字符串。
-
删除长度大于5的字符串，打印删除后的数组。
-
-
代码实现，效果如图所示：
package com.atguigu.test06;
import java.util.Arrays;
public class Test06 {
public static void main(String[] args) {
String[] arr = {"helloworld","java","chai","atguigu","lin","yan","Iloveyou"};
System.out.println("原字符串：");
System.out.println( Arrays.toString(arr));
int index = 0;
while(index < arr.length){
if(arr[index].length()>5){
System.arraycopy(arr, index+1, arr, index, arr.length-index-1);
arr = Arrays.copyOf(arr, arr.length-1);
}else{
index++;
}
}
System.out.println("删除后：");
System.out.println(Arrays.toString(arr));
}
}
第七题
-
判断回文字符串。如果一个字符串，从前向后读和从后向前读，都是一个字符串，称为回文串，比如mom，dad，noon。
-
代码实现，效果如图所示：
package com.atguigu.test07;
import org.junit.Test;
public class Test07 {
@Test
public void test01() {
String str = "noon";
System.out.println(str);
StringBuilder s = new StringBuilder(str);
String string = s.reverse().toString();
System.out.print("回文数：");
if(str.equals(string)){
System.out.println(true);
}else{
System.out.println(false);
}
}
@Test
public void test02() {
String str = "noon";
System.out.println(str);
char[] arr = str.toCharArray();
boolean flag = true;
for (int left = 0,right=arr.length-1; left <=right; left++,right--) {
if(arr[left] != arr[right]){
flag = false;
break;
}
}
System.out.print("回文数：");
if(flag){
System.out.println(true);
}else{
System.out.println(false);
}
}
}第八题
-
校验密码是否合法。
-
必须至少9个字符。
-
必须至少2个大写字符。
-
必须包含小写字母和数字。
-
-
代码实现，效果如图所示：
package com.atguigu.test08;
import org.junit.Test;
public class Test08 {
@Test
public void test01(){
String password = "at1Gui2Gu";
char[] arr = password.toCharArray();
int upCount = 0;
int numCount = 0;
int lowerCount = 0;
for (int i = 0; i < arr.length; i++) {
if(arr[i]>='A' && arr[i]<='Z'){
upCount++;
}else if(arr[i]>='a' && arr[i]<='z'){
lowerCount++;
}else if(arr[i]>='0' && arr[i]<='9'){
numCount++;
}
}
System.out.print(password+"是否合法：");
if(password.length() >=9 && upCount>=2 && numCount!=0 && lowerCount!=0){
System.out.println(true);
}else{
System.out.println(false);
}
}
}
第九题
-
模拟用户登录。
-
定义用户类，属性为用户名和密码。
-
使用数组存储多个用户对象。
-
录入用户和密码，对比用户信息，匹配成功登录成功，否则登录失败。
-
登录失败时，当用户名错误，提示没有该用户。
-
登录失败时，当密码错误时，提示密码有误。
-
-
代码实现，效果如图所示：
package com.atguigu.test09;
import java.util.Scanner;
public class Test09 {
public static void main(String[] args) {
User[] all = new User[3];
all[0] = new User("atguigu","123");
all[1] = new User("chailinyan","8888");
all[2] = new User("java","6666");
for (int i = 0; i < all.length; i++) {
System.out.println(all[i]);
}
Scanner input =new Scanner(System.in);
System.out.print("请输入用户名：");
String username = input.next();
System.out.print("请输入密码：");
String password = input.next();
boolean flag = false;
for (int i = 0; i < all.length; i++) {
if(all[i].getUsername().equals(username) && all[i].getPassword().equals(password)){
flag = true;
break;
}
}
System.out.println("登录结果：" +flag);
input.close();
}
}
class User{
private String username;
private String password;
public User(String username, String password) {
super();
this.username = username;
this.password = password;
}
public User() {
super();
}
public String getUsername() {
return username;
}
public void setUsername(String username) {
this.username = username;
}
public String getPassword() {
return password;
}
public void setPassword(String password) {
this.password = password;
}
@Override
public String toString() {
return username + "-" + password;
}
}第十题
-
定义Handleable接口，具备一个处理字符串数字的抽象方法方法String handleString(String num);
-
处理方式1：取整数部分。
-
处理方式2：保留指定位小数，四舍五入。
-
-
代码实现，效果如图所示：
开发提示：
-
匿名内部类的方式，调用所有抽象方法。
public class Test1 {
public static void main(String[] args) {
String str = "23.23456789";
System.out.println("原数字字符串:" + str);
HandleAble s1 = new HandleAble() {
@Override
public String handleString(String str) {
return str.substring(0, str.indexOf("."));
}
};
String string = s1.handleString(str);
System.out.println("取整后:" + string);
int num = 4;
HandleAble s2 = new HandleAble() {
@Override
public String handleString(String str) {
int i = str.indexOf(".") + num + 1;
char c = str.charAt(i);
//System.out.println(c);
if (c <= '4') {
return str.substring(0, i).toString();
} else {
char c1 = (char) (str.charAt(str.indexOf(".") + num) + 1);
return str.substring(0, i - 1) + c1;
}
}
};
String sss = s2.handleString(str);
System.out.println("保留" + num + "位小数后:" + sss);
}
}
interface HandleAble {
public abstract String handleString(String str);
}
————————————————
版权声明：本文为CSDN博主「小飞侠v科比」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/kai46385076/article/details/95678391第十一题
案例：有一个字符串String abc = “342567891”，请写程序将字符串abc进行升序，可以使用JDK API中的现有的功能方法。
package com.atguigu.test11;
import java.util.Arrays;
public class Test11 {
public static void main(String[] args) {
String abc = "342567891";
char[] arr = abc.toCharArray();
Arrays.sort(arr);
abc = new String(arr);
System.out.println(abc);
}
}
package com.atguigu.test10;
public interface Handleable {
String handleString(String num);
}
package com.atguigu.test10;
import org.junit.Test;
public class Test01 {
@Test
public void test01(){
String str = "23.23456789";
System.out.println("原数字：" + str);
/*
str = new Handleable() {
@Override
public String handleString(String num) {
//查找小数点.位置
int index = num.indexOf(".");
if(index != -1){
num = num.substring(0, num.indexOf("."));
}
return num;
}
}.handleString(str);*/
Handleable h = new Handleable() {
@Override
public String handleString(String num) {
//查找小数点.位置
int index = num.indexOf(".");
if(index != -1){
num = num.substring(0, num.indexOf("."));
}
return num;
}
};
str = h.handleString(str);
System.out.println("取整后：" + str);
}
@Test
public void test03(){
String str = "23.99996789";
System.out.println("原数字：" + str);
final int wei = 4;//截取到小数点后4位，四舍五入
str = new Handleable() {
@Override
public String handleString(String num) {
BigDecimal big = new BigDecimal(num);
BigDecimal b = new BigDecimal("1");
BigDecimal shang = big.divide(b, wei, BigDecimal.ROUND_HALF_UP);
return shang.toString();
}
}.handleString(str);
System.out.println(str);
}
第十二题
案例：
已知一个字符串String str = "1、 hello 2. world 3. java 4.String 5. haha 6、HELLO";
要求统计出现次数最多的字母及其出现的次数。不区分大小写。
package com.atguigu.test12;
import org.junit.Test;
public class Test12 {
@Test
public void test1(){
String str = "1、 hellao 2. world 3. java 4.String 5. haha 6、HELLO";
//把字符串转为小写，因为不区分大小写，方便统计
str = str.toLowerCase();
//把里面的非字母去掉
str = str.replaceAll("[^a-z]","");
//转为字符数组
char[] arr = str.toCharArray();
//统计每个字母出现次数
int[] counts = new int[26];//记录26个字母的次数
/*
counts[0]存'a'的次数 'a'=97 97-97->0
counts[1]存'b'的次数 'b'=98 98-97->1
*/
for (int i = 0; i < arr.length; i++) {
counts[arr[i]-97]++;
}
//找最大值
int max = counts[0];
for (int i = 1; i < counts.length; i++) {
if(max < counts[i]){
max = counts[i];
}
}
//打印最大值和字母
for (int i = 0; i < counts.length; i++) {
if(counts[i] == max){
//i=0 'a'字母
//i=1 'b'字母
System.out.println(((char)(i+97)) + "出现了" + max + "次");
}
}
}
}第十三题
案例：已知字符串String str = "1.hello2.world3.java4.string";要求拆分出每一个单词，并遍历显示
package com.atguigu.test13;
public class Test13 {
public static void main(String[] args) {
String str = "1.hello2.world3.java4.string";
//把开头的1.去掉
str = str.replaceAll("^\\d\\.","");
//按照数字.的格式进行拆分
String[] split = str.split("\\d\\.");
for (int i = 0; i < split.length; i++) {
System.out.println(split[i]);
}
}
}
代码阅读题
第十四题
public static void main(String[] args) {
String str = new String("world");
char[] ch = new char[]{'h','e','l','l','o'};
change(str,ch);
System.out.println(str);
System.out.println(String.valueOf(ch));
}
public static void change(String str, char[] arr){
str = "change";
arr[0] = 'a';
arr[1] = 'b';
arr[2] = 'c';
arr[3] = 'd';
arr[4] = 'e';
}
package com.atguigu.test14;
public class Test14 {
public static void main(String[] args) {
String str = new String("world");
char[] ch = new char[]{'h','e','l','l','o'};
change(str,ch);
System.out.println(str);//world
System.out.println(String.valueOf(ch));//abcde
}
/*
* 方法的参数：引用数据类型传递的是对象地址
* 但是字符串对象不可变
*/
public static void change(String str, char[] arr){
str = "change";
arr[0] = 'a';
arr[1] = 'b';
arr[2] = 'c';
arr[3] = 'd';
arr[4] = 'e';
}
}第十五题
public class Test {
int a;
int b;
String str;
public void f(){
a = 0;
b = 0;
str = "hello";
int[] c = {0};
g(b,c);
System.out.println(a + " " + b + " " + c[0] + "," + str);
}
public void g(int b, int[] c,String s){
a = 1;
b = 1;
c[0] = 1;
s = "world";
}
public static void main(String[] args) {
Test t = new Test();
t.f();
}
}
package com.atguigu.test17;
public class Test {
int a;
int b;
String str;
public void f(){
a = 0;//成员变量 this.a--> t.a = 0
b = 0;//成员变量 this.b --> t.b = 0
str = "hello";//成员变量 this.str -> t.str = "hello"
int[] c = {0}; //f()方法的局部变量，是一个数组
g(b,c,str);//this.g(b,c,str);
System.out.println(a + " " + b + " " + c[0] + "," + str);//101hello
}
/*
* 形参基本数据类型：传递数据值
* 形参引用数据类型：传递地址值，但是字符串对象不可变
*/
public void g(int b, int[] c,String s){
a = 1;//修改成员变量 this.a -> t.a = 1
b = 1;//修改形参b，局部变量，(1)和成员变量b无关，(2)因为b是基本数据类型，所以和实参b也无关
c[0] = 1;//c是数组，是引用数据类型，修改元素会影响实参
s = "world";//s是局部变量， 但是字符串对象不可变，和实参无关
}
public static void main(String[] args) {
Test t = new Test();//t.a = 0, t.b = 0, t.str = null
t.f();
}
}第十六题
package com.atguigu.test18;
public class Test18 {
/*
* 形参是引用数据类型，实参传递的是地址值
*/
private static void change(String s,StringBuffer sb){
s = "aaaa";//字符串对象是不可变，一旦修改，就是新对象
sb.setLength(0);//先把sb里面的内容给清空了
sb.append("aaaa");//再拼接aaaa
}
public static void main(String[] args) {
String s = "bbbb";
StringBuffer sb = new StringBuffer("bbbb");
change(s,sb);
System.out.println(s+sb);//bbbbaaaa
}
}
第十七题
package com.atguigu.test19;
public class Example {
String str = new String("good");
char[] ch = {'a','b','c'};
public static void main(String[] args) {
Example ex = new Example();//ex.str = good ex.ch= abc
ex.change(ex.str, ex.ch);
System.out.print(ex.str + " and ");//good + and + gbc
System.out.print(ex.ch);
}
public void change(String str, char[] ch){//形参和实参指向同一个数组
str = "test ok";//字符串对象不可变，形参的修改，和实参无关
ch[0] = 'g';//形参对元素的修改，直接修改的是实参元素的值
}
}
第十八题
package com.atguigu.test20;
public class Test20 {
public static void main(String[] args) {
StringBuffer a = new StringBuffer("A");
StringBuffer b = new StringBuffer("B");
operate(a, b);
System.out.println(a + "," + b);// AB , B
}
public static void operate(StringBuffer x, StringBuffer y) {
x.append(y);// 等价于a拼接b x = AB
y = x;// 一旦修改形参的地址值，那么就和实参无关了，即让形参重新指向新的对象了
y.append('x');
}
}
第十九题
package com.atguigu.test21;
class TEXT{
public int num;
public String str;
public TEXT(int num, String str){
this.num = num;
this.str = str;
}
}
public class Class4 {
//tIn是传对象的地址，修改形参的属性，会影响实参
//intIn是传数据，基本数据类型的形参修改和实参无关
//Integer和String对象不可变
public static void f1(TEXT tIn, int intIn, Integer integerIn, String strIn){
tIn.num =200;
tIn.str = "bcd";//形参和实参指向的是同一个TEXT的对象，修改了属性，就相当于修改实参对象的属性
intIn = 200;//基本数据类型的形参是实参的“副本”，无论怎么修改和实参都没关系
integerIn = 200;//Integer对象和String对象一样都是不可变，一旦修改都是新对象，和实参无关
strIn = "bcd";
}
public static void main(String[] args) {
TEXT tIn = new TEXT(100, "abc");//tIn.num = 100, tIn.str="abc"
int intIn = 100;
Integer integerIn = 100;
String strIn = "abc";
f1(tIn,intIn,integerIn,strIn);
System.out.println(tIn.num + tIn.str + intIn + integerIn + strIn);
//200 + bcd + 100 + 100 + abc
}
}
第二十题
package com.atguigu.test22;
public class Test22 {
/*
* GBK，UTF-8，ISO8859-1所有的字符编码都向下兼容ASCII码
*/
public static void main(String[] args) throws Exception {
String str = "中国";
System.out.println(str.getBytes("ISO8859-1").length);// 2
// ISO8859-1把所有的字符都当做一个byte处理，处理不了多个字节
System.out.println(str.getBytes("GBK").length);// 4 每一个中文都是对应2个字节
System.out.println(str.getBytes("UTF-8").length);// 6 常规的中文都是3个字节
/*
* 不乱码：（1）保证编码与解码的字符集名称一样（2）不缺字节
*/
System.out.println(new String(str.getBytes("ISO8859-1"), "ISO8859-1"));// 乱码
System.out.println(new String(str.getBytes("GBK"), "GBK"));// 中国
System.out.println(new String(str.getBytes("UTF-8"), "UTF-8"));// 中国
}
}第十六章
泛型练习题
第一题
案例：有如下四个学生的成绩：
（1）用Comparable接口对下列四位同学的成绩做降序排序，如果成绩一样，那在成绩排序的基础上按照年龄由小到大排序。请正确指定泛型
（2）用Comparator实现按照姓名排序，请正确指定泛型
效果如下
package com.atguigu.test01;
import java.util.Comparator;
import java.util.TreeSet;
public class Test01 {
public static void main(String[] args) {
System.out.println("按照成绩和年龄排序：");
TreeSet<Student> set = new TreeSet<>();
set.add(new Student("liusan",20,90.0));
set.add(new Student("lisi",22,90.0));
set.add(new Student("wangwu",20,99.0));
set.add(new Student("sunliu",22,100.0));
for (Student student : set) {
System.out.println(student);
}
System.out.println("按照姓名排序：");
TreeSet<Student> all = new TreeSet<>(new Comparator<Student>() {
@Override
public int compare(Student o1, Student o2) {
return o1.getName().compareTo(o2.getName());
}
});
all.addAll(set);
for (Student student : all) {
System.out.println(student);
}
}
}
class Student implements Comparable<Student>{
private String name;
private int age;
private double score;
public Student(String name, int age, double score) {
super();
this.name = name;
this.age = age;
this.score = score;
}
public Student() {
super();
}
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 double getScore() {
return score;
}
public void setScore(double score) {
this.score = score;
}
@Override
public String toString() {
return "Student [name=" + name + ", age=" + age + ", score=" + score + "]";
}
@Override
public int compareTo(Student stu) {
if(this.getScore()>stu.getScore()){
return -1;
}else if(this.getScore() < stu.getScore()){
return 1;
}
return this.getAge() - stu.getAge();
}
}第二题
案例：
1、声明一个坐标类Coordinate<T>，它有两个属性：x,y，都为T类型
2、在测试类中，创建两个不同的坐标类对象，分别指定T类型为String和Double，并为x,y赋值，打印对象
package com.atguigu.test02;
public class Test02 {
public static void main(String[] args) {
Coordinate<Double> c1 = new Coordinate<>(123.5, 30.0);
System.out.println(c1);
Coordinate<String> c2 = new Coordinate<>("东经123.5°", "北纬30°");
System.out.println(c2);
}
}
class Coordinate<T>{
private T x;
private T y;
public Coordinate(T x, T y) {
super();
this.x = x;
this.y = y;
}
public Coordinate() {
super();
}
public T getX() {
return x;
}
public void setX(T x) {
this.x = x;
}
public T getY() {
return y;
}
public void setY(T y) {
this.y = y;
}
@Override
public String toString() {
return "Coordinate [x=" + x + ", y=" + y + "]";
}
}第三题
案例：
1、声明泛型方法，可以实现任意引用类型数组指定位置元素交换。
public static <T> void method( T[] arr,int a,int b)
2、在主方法中调用测试
package com.atguigu.test03;
public class Test03 {
public static void main(String[] args) {
Integer[] arr = {1,2,3,4,5,6};
method(arr,0,1);
for (Integer num : arr) {
System.out.println(num);
}
}
public static <T> void method( T[] arr,int a,int b){
//元素互换
T temp = arr[a];
arr[a] = arr[b];
arr[b] = temp;
}
}
第四题
案例：
1、声明泛型方法，可以接收一个任意引用类型的数组，并反转数组中的所有元素
public static <T> void reverse(T[] arr)
2、在主方法中调用测试
package com.atguigu.test04;
import java.util.Arrays;
public class Test04 {
public static void main(String[] args) {
Integer[] arr = {1,2,3,4,5,6};
reverse(arr);
System.out.println(Arrays.toString(arr));
}
public static <T> void reverse(T[] arr){
for (int i = 0; i < arr.length/2; i++) {
T temp = arr[i];
arr[i] = arr[arr.length-1-i];
arr[arr.length-1-i] = temp;
}
}
}
第五题
案例：
1、声明泛型方法，可以给任意对象数组按照元素的自然排序实现从小到大排序，用冒泡排序实现
public static <T> void sort(T[] arr)
2、声明泛型方法，可以给任意对象数组按照指定的比较器实现从小到大排序，用冒泡排序实现
public static <T> void sort(T[] arr, Comparator<? super T> c)
package com.atguigu.test05;
import java.util.Arrays;
import java.util.Comparator;
public class Test05 {
public static void main(String[] args) {
Integer[] arr = {2,4,7,1,3};
sort(arr);
System.out.println(Arrays.toString(arr));
String[] all = {"hello","Hello","Chai","chai"};
sort(all,new Comparator<String>() {
@Override
public int compare(String o1, String o2) {
return o1.compareToIgnoreCase(o2);
}
});
System.out.println(Arrays.toString(all));
}
public static <T extends Comparable<T>> void sort(T[] arr){
for (int i = 1; i < arr.length; i++) {
for (int j = 0; j < arr.length-i; j++) {
if(arr[j].compareTo(arr[j+1])>0){
T temp = arr[j];
arr[j] = arr[j+1];
arr[j+1] = temp;
}
}
}
}
public static <T> void sort(T[] arr, Comparator<? super T> c){
for (int i = 1; i < arr.length; i++) {
for (int j = 0; j < arr.length-i; j++) {
if(c.compare(arr[j], arr[j+1])>0){
T temp = arr[j];
arr[j] = arr[j+1];
arr[j+1] = temp;
}
}
}
}
}
集合练习题
第一题
-
随机验证码。
-
随机生成十组六位字符组成的验证码。
-
验证码由大小写字母、数字字符组成。
-
-
代码实现，效果如图所示：
-
开发提示：
使用字符数组保存原始字符，利用Random类生成随机索引。
将十组验证码放到集合中
用Iterator迭代器遍历集合
package com.atguigu.test01;
import java.util.Collection;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.Random;
public class Test01 {
@SuppressWarnings("all")
public static void main(String[] args) {
char[] arr = new char[26+26+10];
//使用字符数组保存原始字符
for (int i = 0; i < arr.length; i++) {
if(i<10){//前10个放数字
arr[i] = (char)(i+48);
}else if(i<10+26){//中间26个放大写字母
arr[i] = (char)(i+65-10);
}else{//剩下的放小写字母
arr[i] = (char)(i+97-10-26);
}
}
//随机生成10组验证码
Collection<String> list = new ArrayList<String>();
Random rand = new Random();
for (int i = 0; i < 10; i++) {
String str = "";
for (int j = 0; j < 6; j++) {
int index = rand.nextInt(arr.length);
str += arr[index];
}
list.add(str);
}
Iterator<String> iter = list.iterator();
while(iter.hasNext()){
System.out.println("随机验证码：" + iter.next());
}
}
}
第二题
-
键盘录入学生信息，保存到集合中。
-
循环录入的方式，1：表示继续录入，0：表示结束录入。
-
定义学生类，属性为姓名，年龄，使用学生对象保存录入数据。
-
使用ArrayList集合，保存学生对象，录入结束后，用foreach遍历集合。
-
-
代码实现，效果如图所示：
package com.atguigu.test02;
import java.util.Collection;
import java.util.ArrayList;
import java.util.Scanner;
public class Test02 {
public static void main(String[] args) {
Collection<Student> list = new ArrayList<Student>();
Scanner input = new Scanner(System.in);
while(true){
System.out.print("选择（1、录入；0、退出）：");
int select = input.nextInt();
if(select == 0){
break;
}
System.out.print("姓名：");
String name = input.next();
System.out.print("年龄：");
int age = input.nextInt();
Student stu = new Student(name,age);
list.add(stu);
}
for (Student stu : list) {
System.out.println(stu);
}
}
}
class Student{
private String name;
private int age;
public Student(String name, int age) {
super();
this.name = name;
this.age = age;
}
public Student() {
super();
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
@Override
public String toString() {
return "Student [name=" + name + ", age=" + age + "]";
}
}第十七章
第一题
案例：
1、用一个String[]数组存点数
2、用一个String[]数组存花色
3、用一个String[]数组存大王、小王
4、用上面的数组，生成一副扑克牌
5、遍历显示全副扑克牌
6、模拟给4个人随机发牌，每个人11张牌
7、显示每个人的牌和剩余的牌
效果如下：
package com.atguigu.test01;
import java.util.ArrayList;
import java.util.Random;
public class Test01 {
public static void main(String[] args) {
String[] dian = {"A","2","3","4","5","6","7","8","9","10","J","Q","K"};
String[] hua = {"黑桃","红桃","方片","梅花"};
String[] wang = {"大王","小王"};
ArrayList<String> list = new ArrayList<String>();
for (int i = 0; i < dian.length; i++) {
for (int j = 0; j < hua.length; j++) {
list.add(hua[j]+dian[i]);
}
}
for (int i = 0; i < wang.length; i++) {
list.add(wang[i]);
}
for (int i = 0; i < list.size(); i++) {
System.out.print(list.get(i)+" ");
if((i+1)%10==0){
System.out.println();
}
}
System.out.println();
System.out.println("发牌：");
Random rand = new Random();
ArrayList<String> one = new ArrayList<String>();
for (int i = 0; i < 11; i++) {
one.add(list.remove(rand.nextInt(list.size())));
}
ArrayList<String> two = new ArrayList<String>();
for (int i = 0; i < 11; i++) {
two.add(list.remove(rand.nextInt(list.size())));
}
ArrayList<String> three = new ArrayList<String>();
for (int i = 0; i < 11; i++) {
three.add(list.remove(rand.nextInt(list.size())));
}
ArrayList<String> four = new ArrayList<String>();
for (int i = 0; i < 11; i++) {
four.add(list.remove(rand.nextInt(list.size())));
}
System.out.println("第1个人：" + one);
System.out.println("第2个人：" + two);
System.out.println("第3个人：" + three);
System.out.println("第4个人：" + four);
System.out.println("剩余：" + list);
}
}
第二题
-
模拟乐透号码。
-
随机生成10个号码放到集合中，范围1-50，作为乐透号码。不能重复。
-
键盘录入10个整数放到集合中，范围1-50，不能重复。
-
录入的整数与乐透号码对比，统计猜中了几个。
-
-
代码实现，效果如图所示：
开发提示：
-
当使用集合时，可以通过contains方法，判断某集合中是否包含某元素
package com.atguigu.test02;
import java.util.ArrayList;
import java.util.Random;
import java.util.Scanner;
public class Test02 {
public static void main(String[] args) {
ArrayList<Integer> lotNumList = lotNum();
System.out.println("乐透号码已经生成,游戏开始:");
ArrayList<Integer> inputList = inputNum();
System.out.println("您输入的号码为:"+inputList);
int count = countNum(inputList , lotNumList);
System.out.println("乐透号码为:"+lotNumList);
System.out.println("猜中了:"+count+"个数字");
}
public static int countNum(ArrayList<Integer> inputList, ArrayList<Integer> lotNumList) {
int count = 0;
for (int i = 0; i < inputList.size(); i++) {
Object num = inputList.get(i);
if (lotNumList.contains(num)){
count++;
}
}
return count ;
}
public static ArrayList<Integer> inputNum(){
ArrayList<Integer> list = new ArrayList<Integer>();
Scanner sc = new Scanner(System.in);
for (int i = 0; i < 10; ) {
System.out.println("请输入第"+(i+1)+"个数字[1-50]:");
int num = sc.nextInt();
if (num >=1 && num<=50 && !list.contains(num)){
list.add(num);
i++;
}else{
System.out.println(num+"超过[1-50]范围或重复录入，数字无效，请重新输入");
}
}
sc.close();
return list;
}
public static ArrayList<Integer> lotNum(){
ArrayList<Integer> list = new ArrayList<Integer>();
Random r = new Random();
for (int i = 0; i < 10; ) {
int num = r.nextInt(50) + 1;
if (!list.contains(num)){
list.add(num);
i++;
}
}
return list;
}
}第三题
案例：
1、随机生成10个[1,100]之间的整数，放到List集合中，遍历显示
2、找出前3名最大值，删除它们，注意可能重复
3、显示删除后的结果
效果如下：
package com.atguigu.test03;
import java.util.ArrayList;
import java.util.Random;
public class Test03 {
public static void main(String[] args) {
ArrayList<Integer> nums = getNum();
System.out.println("10个随机值：" + nums);
ArrayList<Integer> maxList = getTop3(nums);
System.out.println("前3个最大的：" + maxList);
System.out.println("删除后：" + nums);
}
public static ArrayList<Integer> getNum() {
ArrayList<Integer> list = new ArrayList<Integer>();
Random r = new Random();
for (int i = 0; i < 10; i++) {
int n = r.nextInt(100) + 1;
list.add(n);
}
return list;
}
public static ArrayList<Integer> getTop3(ArrayList<Integer> list){
ArrayList<Integer> maxList = new ArrayList<Integer>();
for (int i = 0; i < 3; i++) {
Integer max = (Integer) list.get(0);
for (int j = 0; j < list.size(); j++) {
Integer num = (Integer) list.get(j);
if(max < num){
max = num;
}
}
maxList.add(max);
while(list.contains(max)){
list.remove(max);
}
}
return maxList;
}
}
第四题
-
随机生成30个数，范围2-100，获取其中的质数。
-
代码实现，效果如图所示：
开发提示：
-
质数：在一个大于1的整数中，除了1和此整数自身外，没法被其他自然数整除的数。
package com.atguigu.test04;
import java.util.ArrayList;
import java.util.Random;
public class Test04 {
public static void main(String[] args) {
ArrayList<Integer> ranNum = getRanNum();
System.out.println("随机数为:");
System.out.println(ranNum);
System.out.println("其中的质数为:");
ArrayList<Integer> pNum = getPNum(ranNum);
System.out.println(pNum);
}
public static ArrayList<Integer> getPNum(ArrayList<Integer> ranNum) {
ArrayList<Integer> list = new ArrayList<Integer>();
for (int i = 0; i < ranNum.size(); i++) {
Integer integer = (Integer) ranNum.get(i);
if (isP(integer)) {
list.add(integer);
}
}
return list;
}
public static ArrayList<Integer> getRanNum() {
Random random = new Random();
ArrayList<Integer> list = new ArrayList<Integer>();
for (int i = 0; i < 30; i++) {
list.add(random.nextInt(99) + 2);
}
return list;
}
public static boolean isP(int n) {
boolean isPrime = true;
for (int i = 2; i < n; i++) {
if (n % i == 0) {
isPrime = false;
break;
}
}
return isPrime;
}
}
第五题
案例：
1、请定义方法public static int listTest(Collection list,String s)统计集合中指定元素出现的次数
2、创建集合，集合存放随机生成的30个小写字母
3、用listTest统计，某些元素的出现次数
效果如下
package com.atguigu.test05;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Random;
public class Test05 {
public static void main(String[] args) {
ArrayList<String> list = new ArrayList<String>();
Random rand = new Random();
for (int i = 0; i < 30; i++) {
list.add((char)(rand.nextInt(26)+97)+"");
}
System.out.println(list);
System.out.println("a:"+listTest(list, "a"));
System.out.println("b:"+listTest(list, "b"));
System.out.println("c:"+listTest(list, "c"));
System.out.println("x:"+listTest(list, "x"));
}
public static int listTest(Collection<String> list, String string) {
int count = 0;
for (String object : list) {
if(string.equals(object)){
count++;
}
}
return count;
}
}
第六题
案例：键盘录入一个字符串，去掉其中重复字符，打印出不同的那些字符，必须保证顺序。例如输入：aaaabbbcccddd，打印结果为：abcd。效果如图：
提示：LinkedHashSet的使用
package com.atguigu.test06;
import java.util.LinkedHashSet;
import java.util.Scanner;
public class Test06 {
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
System.out.print("请输入一串字母：");
String str = input.nextLine();
System.out.println("str=" + str);
LinkedHashSet<Character> set = new LinkedHashSet<Character>();
for (int i = 0; i < str.length(); i++) {
set.add(str.charAt(i));
}
System.out.print("去重后：");
String result = "";
for (Character object : set) {
result += object;
}
System.out.println(result);
}
}
第七题
案例：双色球规则：双色球每注投注号码由6个红色球号码和1个蓝色球号码组成。红色球号码从1—33中选择；蓝色球号码从1—16中选择；请随机生成一注双色球号码。（要求同色号码不重复）
开发提示：可以使用TreeSet和ArrayList结合
package com.atguigu.test07;
import java.util.ArrayList;
import java.util.Random;
import java.util.TreeSet;
public class Test07 {
public static void main(String[] args) {
TreeSet<Integer> red = new TreeSet<Integer>();
Random rand = new Random();
while(red.size()<6){
red.add(rand.nextInt(33)+1);
}
ArrayList<Integer> list = new ArrayList<Integer>();
list.addAll(red);
list.add(rand.nextInt(16)+1);//蓝色号码
System.out.println("双色球所有号码：" + list);
System.out.print("红色号码：");
for (int i = 0; i < list.size()-1; i++) {
System.out.print(list.get(i)+" ");
}
System.out.println("蓝色号码：" + list.get(list.size()-1));
}
}
第八题
案例：有如下四个学生的成绩：
（1）用Comparable接口对下列四位同学的成绩做降序排序，如果成绩一样，那在成绩排序的基础上按照年龄由小到大排序。
（2）用Comparator实现按照姓名排序
效果如下
package com.atguigu.test08;
import java.util.Comparator;
import java.util.TreeSet;
public class Test08 {
public static void main(String[] args) {
System.out.println("按照成绩和年龄排序：");
TreeSet<Student> set = new TreeSet<Student>();
set.add(new Student("liusan",20,90.0));
set.add(new Student("lisi",22,90.0));
set.add(new Student("wangwu",20,99.0));
set.add(new Student("sunliu",22,100.0));
for (Object object : set) {
System.out.println(object);
}
System.out.println("按照姓名排序：");
TreeSet<Student> all = new TreeSet<Student>(new Comparator<Student>() {
@Override
public int compare(Student o1, Student o2) {
return o1.getName().compareTo(o2.getName());
}
});
for (Student object : set) {
all.add(object);
}
for (Student object : all) {
System.out.println(object);
}
}
}
class Student implements Comparable<Student>{
private String name;
private int age;
private double score;
public Student(String name, int age, double score) {
super();
this.name = name;
this.age = age;
this.score = score;
}
public Student() {
super();
}
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 double getScore() {
return score;
}
public void setScore(double score) {
this.score = score;
}
@Override
public String toString() {
return "Student [name=" + name + ", age=" + age + ", score=" + score + "]";
}
@Override
public int compareTo(Student o) {
if(this.getScore()>o.getScore()){
return -1;
}else if(this.getScore() < o.getScore()){
return 1;
}
return this.getAge() - o.getAge();
}
}第十八章
第一题
开发提示：可以使用Map，key是字母，value是该字母的次数
效果演示：例如：String str = "Your future depends on your dreams, so go to sleep.";
package com.atguigu.test01;
import java.util.HashMap;
import java.util.Map.Entry;
import java.util.Set;
public class Test01 {
public static void main(String[] args) {
String str = "Your future depends on your dreams, so go to sleep.";
str = str.replaceAll("[^a-zA-Z]", "");
HashMap<Character,Integer> map = new HashMap<Character,Integer>();
char[] arr = str.toCharArray();
for (int i = 0; i < arr.length; i++) {
if(map.containsKey(arr[i])){
Integer count = map.get(arr[i]);
map.put(arr[i], count+1);
}else{
map.put(arr[i], 1);
}
}
Set<Entry<Character,Integer>> entrySet = map.entrySet();
for (Entry<Character,Integer> object : entrySet) {
System.out.println(object);
}
}
}
第二题
案例：添加你喜欢的歌手以及你喜欢他唱过的歌曲
例如：
package com.atguigu.test02;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Map.Entry;
import java.util.Set;
public class Test02 {
public static void main(String[] args) {
HashMap<String,ArrayList<String>> map = new HashMap<>();
ArrayList<String> wangfei = new ArrayList<String>();
wangfei.add("《红豆》");
wangfei.add("《传奇》");
wangfei.add("《容易受伤的女人》");
map.put("王菲", wangfei);
ArrayList<String> zxy = new ArrayList<String>();
zxy.add("《一路上有你》");
zxy.add("《吻别》");
zxy.add("《一千个伤心的理由》");
map.put("张学友", zxy);
Set<Entry<String, ArrayList<String>>> entrySet = map.entrySet();
for (Entry<String, ArrayList<String>> object : entrySet) {
System.out.println(object);
}
}
}
第三题
案例：
添加如下省份与城市信息到map中，并遍历显示
浙江省
绍兴市
温州市
湖州市
嘉兴市
台州市
金华市
舟山市
衢州市
丽水市
杭州市
宁波市
海南省
海口市
三亚市
北京市
北京市开发提示：
其中key为省份名，value为该省份所有的市辖区
package com.atguigu.test03;
import java.util.Arrays;
import java.util.HashMap;
import java.util.List;
import java.util.Map.Entry;
import java.util.Set;
public class Test03 {
public static void main(String[] args) throws Exception {
HashMap<String,List<String>> map = new HashMap<>();
map.put("北京市", Arrays.asList("北京市"));
map.put("海南省", Arrays.asList("海口市","三亚市"));
map.put("浙江省", Arrays.asList("绍兴市","温州市","湖州市","嘉兴市","台州市","金华市","舟山市","衢州市","丽水市"));
Set<Entry<String, List<String>>> entrySet = map.entrySet();
for (Entry<String, List<String>> object : entrySet) {
System.out.println(object);
}
}
}
第四题
案例：模拟斗地主洗牌和发牌并对牌进行排序的代码实现
运行效果如下：
开发提示：
（1）用String[] nums = { "3", "4", "5", "6", "7", "8", "9", "10", "J", "Q", "K", "A", "2" };存储数字
String[] colors = { "方片", "梅花", "红桃", "黑桃" };存储花色
（2）单独处理大王、小王
（3）将54张牌的索引[1,54]数字依次存储到一个ArrayList中
（4）用nums和colors数组的组合，将54张牌存储的一个Map中，key是索引，范围是1-54，value是牌面，例如：(1,黑桃3),...(54,小王)
（5）对ArrayList进行洗牌打乱顺序
（6）依次取list中的索引，发给四位牌友，四位牌友的牌可以用TreeSet存储，这样可以按照索引大小排序，索引大小就是牌的大小
（7）遍历结果，TreeSet中存储的是牌的索引，显示的时候从Map中取出牌显示
package com.atguigu.test04;
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.TreeSet;
public class Test04 {
public static void main(String[] args) {
String[] nums = { "3", "4", "5", "6", "7", "8", "9", "10", "J", "Q", "K", "A", "2" };
String[] colors = { "方片", "梅花", "红桃", "黑桃" };
ArrayList<Integer> list = new ArrayList<Integer>(); // 存储54章牌的索引[0,53]
HashMap<Integer,String> map = new HashMap<>(); // 存储索引和扑克牌
int index = 1; // 索引的开始值
for (String num : nums) {
for (String color : colors) {
map.put(index, color.concat(num)); // 将索引和扑克牌添加到HashMap中
list.add(index); // 将索引添加到ArrayList集合中
index++;
}
}
map.put(index, "小王");
list.add(index);
index++;
map.put(index, "大王");
list.add(index);
// 洗牌
Collections.shuffle(list);
// 发牌
TreeSet<Integer> left = new TreeSet<Integer>();
TreeSet<Integer> right = new TreeSet<Integer>();
TreeSet<Integer> me = new TreeSet<Integer>();
TreeSet<Integer> up = new TreeSet<Integer>();
TreeSet<Integer> lastCards = new TreeSet<Integer>();
for (int i = 0; i < 13; i++) {
right.add(list.remove(0));
left.add(list.remove(0));
me.add(list.remove(0));
up.add(list.remove(0));
}
lastCards.addAll(list);
// 看牌
lookPoker("左边玩家", left, map);
lookPoker("右边玩家", right, map);
lookPoker("上边玩家", up, map);
lookPoker("我", me, map);
lookPoker("底牌", lastCards, map);
}
public static void lookPoker(String name, TreeSet<Integer> ts, HashMap<Integer, String> map) {
System.out.println(name + "的牌是:");
for (Integer index : ts) {
System.out.print(map.get(index) + " ");
}
System.out.println();
}
}
第五题
案例：
（1）从键盘输入一个年份，输出该年的世界杯冠军是哪支球队。如果该年没有举办世界杯，则输出：没有举办世界杯。
（2）从键盘输入一支球队的名字，输出该球队夺冠的年份列表。 例如，读入“巴西”，应当输出 1958 1962 1970 1994 2002 读入“荷兰”，应当输出 没有获得过世界杯
运行效果如下：
开发提示：
把年份作为key，改年夺冠的国家名称作为value存到map中
附：历届世界杯冠军
| 届数 | 举办年份 | 举办地点 | 冠军 |
|---|---|---|---|
| 第一届 | 1930年 | 乌拉圭 | 乌拉圭 |
| 第二届 | 1934年 | 意大利 | 意大利 |
| 第三届 | 1938年 | 法国 | 意大利 |
| 第四届 | 1950年 | 巴西 | 乌拉圭 |
| 第五届 | 1954年 | 瑞士 | 西德 |
| 第六届 | 1958年 | 瑞典 | 巴西 |
| 第七届 | 1962年 | 智利 | 巴西 |
| 第八届 | 1966年 | 英格兰 | 英格兰 |
| 第九届 | 1970年 | 墨西哥 | 巴西 |
| 第十届 | 1974年 | 前西德 | 西德 |
| 第十一届 | 1978年 | 阿根廷 | 阿根廷 |
| 第十二届 | 1982年 | 西班牙 | 意大利 |
| 第十三届 | 1986年 | 墨西哥 | 阿根廷 |
| 第十四届 | 1990年 | 意大利 | 西德 |
| 第十五届 | 1994年 | 美国 | 巴西 |
| 第十六届 | 1998年 | 法国 | 法国 |
| 第十七届 | 2002年 | 韩日 | 巴西 |
| 第十八届 | 2006年 | 德国 | 意大利 |
| 第十九届 | 2010年 | 南非 | 西班牙 |
| 第二十届 | 2014年 | 巴西 | 德国 |
| 第二十一届 | 2018年 | 俄罗斯 | 法国 |
package com.atguigu.test05;
import java.util.HashMap;
import java.util.Map;
import java.util.Scanner;
public class Test05 {
public static void main(String[] args) {
Map<Integer,String> m = new HashMap<>();
m.put(1930, "乌拉圭");
m.put(1934, "意大利");
m.put(1938, "意大利");
m.put(1950, "乌拉圭");
m.put(1954, "西德");
m.put(1958, "巴西");
m.put(1962, "巴西");
m.put(1966, "英格兰");
m.put(1970, "巴西");
m.put(1974, "西德");
m.put(1978, "阿根廷");
m.put(1982, "意大利");
m.put(1986, "阿根廷");
m.put(1990, "西德");
m.put(1994, "巴西");
m.put(1998, "法国");
m.put(2002, "巴西");
m.put(2006, "意大利");
m.put(2010, "西班牙");
m.put(2014, "德国");
m.put(2018, "法国");
Scanner input = new Scanner(System.in);
System.out.print("请输入一个年份:");
int key = input.nextInt();
if (m.containsKey(key)) {
System.out.println(key + "年，获得世界杯冠军的是：" + m.get(key));
} else {
System.out.println("该年没有举办世界杯！");
}
System.out.print("请输入一个国家名称:");
String country = input.next();
if (m.containsValue(country)) {
System.out.println("该国球队在如下年份获得过冠军：");
for (Integer year : m.keySet()) {
if (m.get(year).equals(country)) {
System.out.println(year);
}
}
} else {
System.out.println("该国家没有获得世界杯冠军");
}
}
}
第六题
案例：模拟菜单的二级联动效果
现有全国各省市信息字符串如下：
String str = "'北京': ['北京'];"
+"'上海': ['上海'];"
+"'天津': ['天津'];"
+"'重庆': ['重庆'];"
+"'河北省': ['石家庄', '张家口', '承德', '秦皇岛', '唐山', '廊坊', '保定', '沧州', '衡水', '邢台', '邯郸'];"
+"'山西省': ['太原', '大同', '朔州', '阳泉', '长治', '晋城', '忻州', '吕梁', '晋中', '临汾', '运城'];"
+"'辽宁省': ['沈阳', '朝阳', '阜新', '铁岭', '抚顺', '本溪', '辽阳', '鞍山', '丹东', '大连', '营口', '盘锦', '锦州', '葫芦岛'];"
+"'吉林省': ['长春', '白城', '松原', '吉林', '四平', '辽源', '通化', '白山', '延边'];"
+"'黑龙江省': ['哈尔滨', '齐齐哈尔', '黑河', '大庆', '伊春', '鹤岗', '佳木斯', '双鸭山', '七台河', '鸡西', '牡丹江', '绥化', '大兴安'];"
+"'江苏省': ['南京', '徐州', '连云港', '宿迁', '淮阴', '盐城', '扬州', '泰州', '南通', '镇江', '常州', '无锡', '苏州'];"
+"'浙江省': ['杭州', '湖州', '嘉兴', '舟山', '宁波', '绍兴', '金华', '台州', '温州', '丽水','衢州'];"
+"'安徽省': ['合肥', '宿州', '淮北', '阜阳', '蚌埠', '淮南', '滁州', '马鞍山', '芜湖', '铜陵', '安庆', '黄山', '六安', '巢湖', '池州', '宣城'];"
+"'福建省': ['福州', '南平', '三明', '莆田', '泉州', '厦门', '漳州', '龙岩', '宁德'];"
+"'江西省': ['南昌', '九江', '景德镇', '鹰潭', '新余', '萍乡', '赣州', '上饶', '抚州', '宜春', '吉安'];"
+"'山东省': ['济南', '聊城', '德州', '东营', '淄博', '潍坊', '烟台', '威海', '青岛', '日照', '临沂', '枣庄', '济宁', '泰安', '莱芜', '滨州', '菏泽'];"
+"'河南省': ['郑州', '三门峡', '洛阳', '焦作', '新乡', '鹤壁', '安阳', '濮阳', '开封', '商丘', '许昌', '漯河', '平顶山', '南阳', '信阳', '周口', '驻马店'];"
+"'湖北省': ['武汉', '十堰', '襄攀', '荆门', '孝感', '黄冈', '鄂州', '黄石', '咸宁', '荆州', '宜昌', '恩施', '襄樊'];"
+"'湖南省': ['长沙', '张家界', '常德', '益阳', '岳阳', '株洲', '湘潭', '衡阳', '郴州', '永州', '邵阳', '怀化', '娄底', '湘西'];"
+"'广东省': ['广州', '清远', '韶关', '河源', '梅州', '潮州', '汕头', '揭阳', '汕尾', '惠州', '东莞', '深圳', '珠海', '江门', '佛山', '肇庆', '云浮', '阳江', '茂名', '湛江'];"
+"'海南省': ['海口', '三亚'];"
+"'四川省': ['成都', '广元', '绵阳', '德阳', '南充', '广安', '遂宁', '内江', '乐山', '自贡', '泸州', '宜宾', '攀枝花', '巴中', '达川', '资阳', '眉山', '雅安', '阿坝', '甘孜', '凉山'];"
+"'贵州省': ['贵阳', '六盘水', '遵义', '毕节', '铜仁', '安顺', '黔东南', '黔南', '黔西南'];"
+"'云南省': ['昆明', '曲靖', '玉溪', '丽江', '昭通', '思茅', '临沧', '保山', '德宏', '怒江', '迪庆', '大理', '楚雄', '红河', '文山', '西双版纳'];"
+"'陕西省': ['西安', '延安', '铜川', '渭南', '咸阳', '宝鸡', '汉中', '榆林', '商洛', '安康'];"
+"'甘肃省': ['兰州', '嘉峪关', '金昌', '白银', '天水', '酒泉', '张掖', '武威', '庆阳', '平凉', '定西', '陇南', '临夏', '甘南'];"
+"'青海省': ['西宁', '海东', '西宁', '海北', '海南', '黄南', '果洛', '玉树', '海西'];"
+"'内蒙古': ['呼和浩特', '包头', '乌海', '赤峰', '呼伦贝尔盟', '兴安盟', '哲里木盟', '锡林郭勒盟', '乌兰察布盟', '鄂尔多斯', '巴彦淖尔盟', '阿拉善盟'];"
+"'广西': ['南宁', '桂林', '柳州', '梧州', '贵港', '玉林', '钦州', '北海', '防城港', '南宁', '百色', '河池', '柳州', '贺州'];"
+"'西藏': ['拉萨', '那曲', '昌都', '林芝', '山南', '日喀则', '阿里'];"
+"'宁夏': ['银川', '石嘴山', '吴忠', '固原'];"
+"'新疆': ['乌鲁木齐', '克拉玛依', '喀什', '阿克苏', '和田', '吐鲁番', '哈密', '博尔塔拉', '昌吉', '巴音郭楞', '伊犁', '塔城', '阿勒泰'];"
+"'香港': ['香港'];"
+"'澳门': ['澳门'];"
+"'台湾': ['台北', '台南', '其他']";效果如下：
请选择：
1:北京
2:上海
3:天津
4:重庆
5:河北省
6:山西省
7:辽宁省
8:吉林省
9:黑龙江省
10:江苏省
11:浙江省
12:安徽省
13:福建省
14:江西省
15:山东省
16:河南省
17:湖北省
18:湖南省
19:广东省
20:海南省
21:四川省
22:贵州省
23:云南省
24:陕西省
25:甘肃省
26:青海省
27:内蒙古
28:广西
29:西藏
30:宁夏
31:新疆
32:香港
33:澳门
34:台湾
省份：11
该省份共有辖区：[杭州, 湖州, 嘉兴, 舟山, 宁波, 绍兴, 金华, 台州, 温州, 丽水, 衢州]开发提示：
（1）把字符串str字符串先按照;进行拆分，得到34个省（包括23个省，5个自治区，4个直辖市，2个特别行政区，下面的题目描述中，把它们都成为省份）
（2）然后把每个省的字符串，按照:进行拆分，那么:左边的是省份名称，:右边的是该省的各市辖区
（3）把34个省存储到一个HashMap集合中，其中编号是key，省份名是value
（4）把所有省份的城市存储到一个LinkedHashMap集合中，其中省份名是key，该省份的所有城市用一个ArrayList的集合装起来，然后作为value。
（5）注意，字符串处理过程中，注意：[、]、,、'等标点符号的处理
例如：
去掉单引号'
replace("'", "")
去掉[,],',空格
replaceAll("\\[|\\]|\\'| ", "")
package com.atguigu.test06;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.Map.Entry;
import java.util.Scanner;
import java.util.Set;
public class Test06 {
public static void main(String[] args) {
LinkedHashMap<String,ArrayList<String>> all = new LinkedHashMap<>();
HashMap<Integer,String> allProvinces = new HashMap<>();
String str = "'北京': ['北京'];"
+"'上海': ['上海'];"
+"'天津': ['天津'];"
+"'重庆': ['重庆'];"
+"'河北省': ['石家庄', '张家口', '承德', '秦皇岛', '唐山', '廊坊', '保定', '沧州', '衡水', '邢台', '邯郸'];"
+"'山西省': ['太原', '大同', '朔州', '阳泉', '长治', '晋城', '忻州', '吕梁', '晋中', '临汾', '运城'];"
+"'辽宁省': ['沈阳', '朝阳', '阜新', '铁岭', '抚顺', '本溪', '辽阳', '鞍山', '丹东', '大连', '营口', '盘锦', '锦州', '葫芦岛'];"
+"'吉林省': ['长春', '白城', '松原', '吉林', '四平', '辽源', '通化', '白山', '延边'];"
+"'黑龙江省': ['哈尔滨', '齐齐哈尔', '黑河', '大庆', '伊春', '鹤岗', '佳木斯', '双鸭山', '七台河', '鸡西', '牡丹江', '绥化', '大兴安'];"
+"'江苏省': ['南京', '徐州', '连云港', '宿迁', '淮阴', '盐城', '扬州', '泰州', '南通', '镇江', '常州', '无锡', '苏州'];"
+"'浙江省': ['杭州', '湖州', '嘉兴', '舟山', '宁波', '绍兴', '金华', '台州', '温州', '丽水','衢州'];"
+"'安徽省': ['合肥', '宿州', '淮北', '阜阳', '蚌埠', '淮南', '滁州', '马鞍山', '芜湖', '铜陵', '安庆', '黄山', '六安', '巢湖', '池州', '宣城'];"
+"'福建省': ['福州', '南平', '三明', '莆田', '泉州', '厦门', '漳州', '龙岩', '宁德'];"
+"'江西省': ['南昌', '九江', '景德镇', '鹰潭', '新余', '萍乡', '赣州', '上饶', '抚州', '宜春', '吉安'];"
+"'山东省': ['济南', '聊城', '德州', '东营', '淄博', '潍坊', '烟台', '威海', '青岛', '日照', '临沂', '枣庄', '济宁', '泰安', '莱芜', '滨州', '菏泽'];"
+"'河南省': ['郑州', '三门峡', '洛阳', '焦作', '新乡', '鹤壁', '安阳', '濮阳', '开封', '商丘', '许昌', '漯河', '平顶山', '南阳', '信阳', '周口', '驻马店'];"
+"'湖北省': ['武汉', '十堰', '襄攀', '荆门', '孝感', '黄冈', '鄂州', '黄石', '咸宁', '荆州', '宜昌', '恩施', '襄樊'];"
+"'湖南省': ['长沙', '张家界', '常德', '益阳', '岳阳', '株洲', '湘潭', '衡阳', '郴州', '永州', '邵阳', '怀化', '娄底', '湘西'];"
+"'广东省': ['广州', '清远', '韶关', '河源', '梅州', '潮州', '汕头', '揭阳', '汕尾', '惠州', '东莞', '深圳', '珠海', '江门', '佛山', '肇庆', '云浮', '阳江', '茂名', '湛江'];"
+"'海南省': ['海口', '三亚'];"
+"'四川省': ['成都', '广元', '绵阳', '德阳', '南充', '广安', '遂宁', '内江', '乐山', '自贡', '泸州', '宜宾', '攀枝花', '巴中', '达川', '资阳', '眉山', '雅安', '阿坝', '甘孜', '凉山'];"
+"'贵州省': ['贵阳', '六盘水', '遵义', '毕节', '铜仁', '安顺', '黔东南', '黔南', '黔西南'];"
+"'云南省': ['昆明', '曲靖', '玉溪', '丽江', '昭通', '思茅', '临沧', '保山', '德宏', '怒江', '迪庆', '大理', '楚雄', '红河', '文山', '西双版纳'];"
+"'陕西省': ['西安', '延安', '铜川', '渭南', '咸阳', '宝鸡', '汉中', '榆林', '商洛', '安康'];"
+"'甘肃省': ['兰州', '嘉峪关', '金昌', '白银', '天水', '酒泉', '张掖', '武威', '庆阳', '平凉', '定西', '陇南', '临夏', '甘南'];"
+"'青海省': ['西宁', '海东', '西宁', '海北', '海南', '黄南', '果洛', '玉树', '海西'];"
+"'内蒙古': ['呼和浩特', '包头', '乌海', '赤峰', '呼伦贝尔盟', '兴安盟', '哲里木盟', '锡林郭勒盟', '乌兰察布盟', '鄂尔多斯', '巴彦淖尔盟', '阿拉善盟'];"
+"'广西': ['南宁', '桂林', '柳州', '梧州', '贵港', '玉林', '钦州', '北海', '防城港', '南宁', '百色', '河池', '柳州', '贺州'];"
+"'西藏': ['拉萨', '那曲', '昌都', '林芝', '山南', '日喀则', '阿里'];"
+"'宁夏': ['银川', '石嘴山', '吴忠', '固原'];"
+"'新疆': ['乌鲁木齐', '克拉玛依', '喀什', '阿克苏', '和田', '吐鲁番', '哈密', '博尔塔拉', '昌吉', '巴音郭楞', '伊犁', '塔城', '阿勒泰'];"
+"'香港': ['香港'];"
+"'澳门': ['澳门'];"
+"'台湾': ['台北', '台南', '其他']";
String[] provincesStr = str.split(";");
for (int i = 0; i < provincesStr.length; i++) {
String[] split = provincesStr[i].split(":");
String proviceName = split[0].replace("'", "");
allProvinces.put(i+1, proviceName);
ArrayList<String> cityList = new ArrayList<String>();
String[] cityStrings = split[1].replaceAll("\\[|\\]|\\'| ", "").split(",");
for (int j = 0; j < cityStrings.length; j++) {
cityList.add(cityStrings[j]);
}
all.put(proviceName, cityList);
}
Scanner input = new Scanner(System.in);
System.out.println("请选择：");
Set<Entry<Integer, String>> entrySet = allProvinces.entrySet();
for (Entry<Integer, String> object : entrySet) {
System.out.println(object);
}
System.out.print("省份：");
int select = input.nextInt();
System.out.println("该省份共有辖区：" + all.get(allProvinces.get(select)));
}
}
第十九章
文件操作
第一题
案例：
1、使用绝对路径，在D盘下创建一个testIO文件夹，然后在testIO文件夹中创建一个1.txt文件
2、使用相对路径，在当前项目下创建一个testIO文件夹，然后在testIO文件夹中创建一个1.txt文件
package com.atguigu.test01;
import java.io.File;
import java.io.IOException;
import org.junit.Test;
public class Test01 {
@Test
public void test01() throws IOException {
File dir = new File("d:/testIO");
dir.mkdir();
File file = new File("d:/testIO/1.txt");
file.createNewFile();
}
@Test
public void test02() throws IOException {
File dir = new File("testIO");
dir.mkdir();
File file = new File("testIO/1.txt");
file.createNewFile();
}
}第二题
案例：
1、检查D盘的testIO文件夹下是否存在文件a.txt，如果不存在则创建该文件。
2、获取D盘的testIO文件夹下的a.txt文件的文件名，文件大小，文件的绝对路径和父路径等信息，并将信息输出在控制台
3、判断File file = new File("d:\testIO");是否文件,是文件则输出：xxx是一个文件，是否文件夹,是文件夹则输出：xxx是一个文件夹
4、删除D盘的testIO文件夹下的a.txt文件
5、删除当前项目下的testIO文件夹下的1.txt文件，然后删除testIO文件夹
package com.atguigu.test02;
import java.io.File;
import java.io.IOException;
import org.junit.Test;
public class Test02 {
@Test
public void test05(){
File file = new File("d:/testIO/1.txt");
file.delete();
File dir = new File("d:/testIO");
dir.delete();
}
@Test
public void test04(){
File file = new File("d:/testIO/a.txt");
file.delete();
}
@Test
public void test03(){
File file = new File("d:/testIO");
if(file.isFile()){
System.out.println(file+"是一个文件。");
}else if(file.isDirectory()){
System.out.println(file + "是一个文件夹");
}
}
@Test
public void test02(){
File file = new File("d:/testIO/a.txt");
System.out.println("文件名：" + file.getName());
System.out.println("文件大小：" + file.length());
System.out.println("文件的绝对路径：" + file.getAbsolutePath());
System.out.println("文件的父目录：" + file.getParent());
}
@Test
public void test01(){
File file = new File("d:/testIO/a.txt");
try {
if(!file.exists()){
file.createNewFile();
}
} catch (IOException e) {
e.printStackTrace();
}
}
}IO流操作
第三题
案例：
1、把老师的word笔记文档《第14章 IO流.docx》，复制到当前项目的testIO文件夹下。
2、要求使用缓冲流和文件流一起实现
package com.atguigu.test03;
import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
public class Test03 {
public static void main(String[] args) {
try(
BufferedInputStream bis = new BufferedInputStream(
new FileInputStream("D:/尚硅谷_190513班_柴林燕_JavaSE/笔记/第14章 IO流.docx"));
BufferedOutputStream bos = new BufferedOutputStream(
new FileOutputStream("testIO/第14章 IO流.docx"));
){
byte[] data = new byte[1024];
int len;
while((len = bis.read(data))!=-1){
bos.write(data, 0, len);
}
}catch(IOException e){
e.printStackTrace();
}
}
}第四题
案例：
把今天的作业文件夹day22_homework下的《我想对你说.txt》字符编码为GBK，复制到当前项目的testIO文件夹下的《柴老师的话.txt》字符编码为UTF-8
package com.atguigu.test04;
import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
public class Test04 {
public static void main(String[] args) {
try(
FileInputStream fis = new FileInputStream("d:/atguigu/day22_homework/我想对你说.txt");
BufferedInputStream bis = new BufferedInputStream(fis);
InputStreamReader isr = new InputStreamReader(bis,"GBK");
FileOutputStream fos = new FileOutputStream("testIO/柴老师的话.txt");
BufferedOutputStream bos = new BufferedOutputStream(fos);
OutputStreamWriter osw = new OutputStreamWriter(bos, "UTF-8");
){
char[] data = new char[1024];
int len;
while((len = isr.read(data))!=-1){
osw.write(data, 0, len);
}
}catch(IOException e){
e.printStackTrace();
}
}
}
第五题
案例：
把如下这些数据存放到一个data.dat文件中，并且再次读取显示
int a = 10;
char c = 'a';
double d = 2.5;
boolean b = true;
String str = "尚硅谷";package com.atguigu.test05;
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import org.junit.Test;
public class Test05 {
@Test
public void test02() throws IOException {
DataInputStream dis = new DataInputStream(new FileInputStream("data.dat"));
System.out.println(dis.readInt());
System.out.println(dis.readChar());
System.out.println(dis.readDouble());
System.out.println(dis.readBoolean());
System.out.println(dis.readUTF());
dis.close();
}
@Test
public void test01() throws IOException {
int a = 10;
char c = 'a';
double d = 2.5;
boolean b = true;
String str = "尚硅谷";
DataOutputStream dos = new DataOutputStream(new FileOutputStream("data.dat"));
dos.writeInt(a);
dos.writeChar(c);
dos.writeDouble(d);
dos.writeBoolean(b);
dos.writeUTF(str);
dos.close();
}
}第六题
案例：
1、声明一个Message类，包含：发送者、接收者、消息内容、发送时间
2、创建一个Message对象，并写到message.dat文件中，并再次读取显示
package com.atguigu.test06;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;
import org.junit.Test;
public class Test06 {
@Test
public void test02() throws FileNotFoundException, IOException, ClassNotFoundException{
ObjectInputStream ois = new ObjectInputStream(new FileInputStream("message.dat"));
Object msg = ois.readObject();
System.out.println(msg);
ois.close();
}
@Test
public void test01() throws FileNotFoundException, IOException{
Message msg = new Message("柴老师", "佟老师", "加工资", System.currentTimeMillis());
ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("message.dat"));
oos.writeObject(msg);
oos.close();
}
}
class Message implements Serializable{
private static final long serialVersionUID = 1L;
private String fromUser;
private String toUser;
private String content;
private long sendTime;
public Message(String fromUser, String toUser, String content, long sendTime) {
super();
this.fromUser = fromUser;
this.toUser = toUser;
this.content = content;
this.sendTime = sendTime;
}
public Message() {
super();
}
public String getFromUser() {
return fromUser;
}
public void setFromUser(String fromUser) {
this.fromUser = fromUser;
}
public String getToUser() {
return toUser;
}
public void setToUser(String toUser) {
this.toUser = toUser;
}
public String getContent() {
return content;
}
public void setContent(String content) {
this.content = content;
}
public long getSendTime() {
return sendTime;
}
public void setSendTime(long sendTime) {
this.sendTime = sendTime;
}
@Override
public String toString() {
return "Message [fromUser=" + fromUser + ", toUser=" + toUser + ", content=" + content + ", sendTime="
+ sendTime + "]";
}
}第七题
案例：
1、使用从键盘输入三句话，用PrintStream打印到一个words.txt文件中
2、再用Scanner一行一行读取显示
package com.atguigu.test07;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.PrintStream;
import java.util.Scanner;
import org.junit.Test;
public class Test07 {
@Test
public void test02() throws FileNotFoundException{
Scanner input = new Scanner(new File("words.txt"));
while(input.hasNextLine()){
System.out.println(input.nextLine());
}
input.close();
}
@Test
public void test01() throws FileNotFoundException{
Scanner input = new Scanner(System.in);
PrintStream ps = new PrintStream("words.txt");
for (int i = 0; i < 3; i++) {
System.out.println("请输入第" + (i+1) + "句要对柴老师说的话：");
String content = input.nextLine();
ps.println(content);
}
input.close();
ps.close();
}
}
递归
第八题
案例：获取D盘atguigu文件夹下所有的.java文件
（1）不包含子文件夹
（2）包含子文件夹
package com.atguigu.test08;
import java.io.File;
import java.io.FileFilter;
import java.util.ArrayList;
import org.junit.Test;
public class Test08 {
@Test
public void test01(){
File file = new File("D:/atguigu");
//不包含子文件夹中的
File[] listFiles = file.listFiles(new FileFilter() {
@Override
public boolean accept(File pathname) {
return pathname.getName().endsWith(".java");
}
});
for (File sub : listFiles) {
System.out.println(sub);
}
}
@Test
public void test02() {
File file = new File("D:/atguigu");
//包含子文件夹中的
ArrayList<String> all = listAllSubs(file);
for (String string : all) {
System.out.println(string);
}
}
public ArrayList<String> listAllSubs(File file){
ArrayList<String> list = new ArrayList<>();
if(file.isFile()){
if(file.getName().endsWith(".java")){
list.add(file.getPath());
}
}else if(file.isDirectory()){
File[] listFiles = file.listFiles();
for (File sub : listFiles) {
list.addAll(listAllSubs(sub));
}
}
return list;
}
}
第九题
案例：统计《尚硅谷190513班柴林燕_JavaSE》文件夹大小
package com.atguigu.test09;
import java.io.File;
import org.junit.Test;
public class Test09 {
@Test
public void test01(){
File file = new File("d:/尚硅谷_190513班_柴林燕_JavaSE");
long size = size(file);
System.out.println("文件夹总大小：" + size);
}
public long size(File file){
if(file.isFile()){
return file.length();
}else if(file.isDirectory()){
File[] listFiles = file.listFiles();
long sum = 0;
for (File sub : listFiles) {
sum += size(sub);
}
return sum;
}
return 0;
}
}
第十题
案例：复制《尚硅谷190513班柴林燕_JavaSE》到当前项目的testIO文件夹中
package com.atguigu.test10;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import org.junit.Test;
public class Test10 {
@Test
public void test01() throws IOException{
File src = new File("d:/作业与成绩");
File dest = new File("testIO");
copyDir(src, dest);
}
public void copyDir(File src, File dest) throws IOException{
if(dest.isFile()){
throw new RuntimeException(dest +"不是文件夹");
}
if(src.isFile()){
File destFile = new File(dest.getPath()+"/" + src.getName());
copyFile(src, destFile);
}else if(src.isDirectory()){
File destFile = new File(dest.getPath()+"/" + src.getName());
destFile.mkdir();
File[] listFiles = src.listFiles();
for (File sub : listFiles) {
copyDir(sub,destFile);
}
}
}
public void copyFile(File srcFile, File destFile) throws IOException{
FileInputStream fis = new FileInputStream(srcFile);
FileOutputStream fos = new FileOutputStream(destFile);
byte[] data = new byte[1024];
int len;
while((len = fis.read(data)) !=-1){
fos.write(data, 0, len);
}
fis.close();
fos.close();
}
}
第十一题
案例：删除当前项目的testIO文件夹
package com.atguigu.test11;
import java.io.File;
import org.junit.Test;
public class Test11 {
@Test
public void test01(){
deleteDir(new File("testIO"));
}
public void deleteDir(File dir){
if(dir.isDirectory()){
File[] listFiles = dir.listFiles();
for (File sub : listFiles) {
deleteDir(sub);
}
}
dir.delete();
}
}
第十二题
案例：剪切《尚硅谷190513班柴林燕_JavaSE》到当前项目的testIO文件夹中
package com.atguigu.test12;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import org.junit.Test;
public class Test12 {
@Test
public void test01() throws IOException{
File src = new File("testIO");
File dest = new File("testIO2");
cutDir(src, dest);
}
public void cutDir(File src, File dest) throws IOException{
if(dest.isFile()){
throw new RuntimeException(dest +"不是文件夹");
}
if(src.isFile()){
File destFile = new File(dest.getPath()+"/" + src.getName());
copyFile(src, destFile);
}else if(src.isDirectory()){
File destFile = new File(dest.getPath()+"/" + src.getName());
destFile.mkdir();
File[] listFiles = src.listFiles();
for (File sub : listFiles) {
cutDir(sub,destFile);
}
}
src.delete();
}
public void copyFile(File srcFile, File destFile) throws IOException{
FileInputStream fis = new FileInputStream(srcFile);
FileOutputStream fos = new FileOutputStream(destFile);
byte[] data = new byte[1024];
int len;
while((len = fis.read(data)) !=-1){
fos.write(data, 0, len);
}
fis.close();
fos.close();
}
}
第二十章
第一题
案例：客户端模拟学生咨询，服务器端模拟咨询老师，进行交互。
客户端收到信息：
欢迎咨询尚硅谷
报满了,请报下一期吧
服务器端收到信息：
你好，我想报名就业班
好吧，再见！
开发提示：
（1）如果是一个客户端与服务器端交互，怎么实现
（2）如果是多个客户端与服务器交互，怎么实现
package com.atguigu.test01;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintStream;
import java.net.Socket;
public class Test01Client {
public static void main(String[] args) throws IOException {
Socket socket = new Socket("127.0.0.1", 8888); // 创建Socket指定ip地址和端口号
// 获取输入流
BufferedReader br = new BufferedReader(new InputStreamReader(socket.getInputStream()));
System.out.println(br.readLine());
// 获取输出流
PrintStream ps = new PrintStream(socket.getOutputStream());
ps.println("你好，我想报名就业班");
System.out.println(br.readLine());
ps.println("好吧，再见！");
socket.close();
}
}
package com.atguigu.test01;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintStream;
import java.net.ServerSocket;
import java.net.Socket;
import java.time.LocalDateTime;
public class Test01Server1 {
public static void main(String[] args) throws IOException {
ServerSocket server = new ServerSocket(8888);
Socket socket = server.accept();
// 获取输出流
PrintStream ps = new PrintStream(socket.getOutputStream());
ps.println("欢迎咨询尚硅谷");
// 获取输入流
BufferedReader br = new BufferedReader(new InputStreamReader(socket.getInputStream()));
System.out.println(socket.getInetAddress().getHostAddress() + "留言：" + LocalDateTime.now());
System.out.println(br.readLine() + "\n");
ps.println("报满了,请报下一期吧");
System.out.println(socket.getInetAddress().getHostAddress() + "留言：" + LocalDateTime.now());
System.out.println(br.readLine());
socket.close();
server.close();
}
}package com.atguigu.test01;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintStream;
import java.net.ServerSocket;
import java.net.Socket;
import java.time.LocalDateTime;
public class Test01Server2 {
public static void main(String[] args) throws IOException {
ServerSocket server = new ServerSocket(8888);
boolean flag = true;
while(flag){
Socket socket = server.accept();
new Thread(){
public void run(){
try {
// 获取输出流
PrintStream ps = new PrintStream(socket.getOutputStream());
ps.println("欢迎咨询尚硅谷");
// 获取输入流
BufferedReader br = new BufferedReader(new InputStreamReader(socket.getInputStream()));
System.out.println(socket.getInetAddress().getHostAddress() + "留言：" + LocalDateTime.now());
System.out.println(br.readLine() + "\n");
ps.println("报满了,请报下一期吧");
System.out.println(socket.getInetAddress().getHostAddress() + "留言：" + LocalDateTime.now());
System.out.println(br.readLine());
socket.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}.start();
}
server.close();
}
}第二题
案例：模拟客户端输入要查询的中文，服务器返回对应的英文单词
效果如下：
开发提示：
（1）服务器端有一个map，key是中文词语，value是对应的单词
（2）服务器接收到客户端的词语后，从map中get，如果可以找到，就返回单词，如果找不到，就返回“没有找到”
package com.atguigu.test02;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintStream;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.HashMap;
public class Test02Server {
public static void main(String[] args) throws IOException {
HashMap<String, String> dictionary = new HashMap<String, String>();
dictionary.put("星期一", "Monday");
dictionary.put("星期二", "Tuesday");
dictionary.put("星期三", "Wednesday");
dictionary.put("星期四", "Thursday");
dictionary.put("星期五", "Friday");
dictionary.put("星期六", "Saturday");
dictionary.put("星期七", "Sunday");
//...
ServerSocket server = new ServerSocket(8888);
Socket socket = server.accept();
// 获取输入流
BufferedReader br = new BufferedReader(new InputStreamReader(socket.getInputStream()));
// 获取输出流
PrintStream ps = new PrintStream(socket.getOutputStream());
//接收客户端的中文
String key = br.readLine();
//查询对应的英文单词，并返回结果
String words = dictionary.get(key);
if(words != null){
ps.println(words);
}else{
ps.println("o(╥﹏╥)o没有找到对应的单词！");
}
socket.close();
server.close();
}
}
package com.atguigu.test02;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintStream;
import java.net.Socket;
import java.util.Scanner;
public class Test02Client {
public static void main(String[] args) throws IOException {
// 创建Socket指定ip地址和端口号
Socket socket = new Socket("127.0.0.1", 8888);
Scanner input = new Scanner(System.in);
System.out.print("请输入要查询的词语：");
String content = input.next();
// 获取输出流
PrintStream ps = new PrintStream(socket.getOutputStream());
ps.println(content);
// 获取输入流
BufferedReader br = new BufferedReader(new InputStreamReader(socket.getInputStream()));
System.out.println("查询结果：" + br.readLine());
socket.close();
input.close();
}
}第三题
案例：客户端给服务器端上传照片
要求：（1）客户端上传的照片，需要是jpg格式的，并且大小在2M（含）以内的，否则不能上传
（2）要求上传成功后，服务器要返回上传成功，如果上传失败，服务器返回上传失败
（3）客户端上传到服务器端的照片，存储在项目名下"photo"的文件夹中，并且以“照片原文件名+时间戳.jpg”命名
效果如下：
package com.atguigu.test03;
import java.io.DataInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.PrintStream;
import java.net.ServerSocket;
import java.net.Socket;
public class Test03Server{
public static void main(String[] args) throws IOException {
//开启服务器
ServerSocket server = new ServerSocket(8888);
//接收一个客户端的连接
Socket socket = server.accept();
//获取输入流
DataInputStream dis = new DataInputStream(socket.getInputStream());
//获取输出流
PrintStream ps = new PrintStream(socket.getOutputStream());
//(1)先读取文件名
String filename = dis.readUTF();
//(2)生成唯一的文件名
String destfile = "photo" + "/" + filename + System.currentTimeMillis() + ".jpg";
//(3)读取文件内容，并写入目标文件
FileOutputStream fos = new FileOutputStream(destfile);
try {
byte[] data = new byte[1024];
int len;
while((len = dis.read(data)) != -1){
fos.write(data, 0, len);
}
//返回结果给客户端
ps.println("接收成功！");
} catch (Exception e) {
//返回结果给客户端
ps.println("接收失败！");
}finally{
fos.close();
}
server.close();
}
}
package com.atguigu.test03;
import java.io.BufferedReader;
import java.io.DataOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.net.Socket;
import java.util.Scanner;
public class Test03Client {
public static void main(String[] args)throws IOException {
//连接服务器
Socket socket= new Socket("127.0.0.1",8888);
//选择要上传的文件
Scanner input = new Scanner(System.in);
System.out.println("请选择要上传的文件：");
//例如：D:\尚硅谷_0325班_柴林燕_JavaSE\笔记\第14章 IO流.docx
String fileStr = input.nextLine();
File file = new File(fileStr);
if(!fileStr.endsWith(".jpg")){
System.out.println("照片必须是.jpg格式");
input.close();
socket.close();
return;
}
if(file.length()>1024*1024*2){
System.out.println("照片必须在2M(含)以内");
input.close();
socket.close();
return;
}
DataOutputStream dos = null;
//从file读取内容，给服务器发送
FileInputStream fis = null;
try {
//获取输出流
dos = new DataOutputStream(socket.getOutputStream());
//先发送文件名
dos.writeUTF(file.getName().substring(0, file.getName().lastIndexOf(".")));
//发送文件内容
fis = new FileInputStream(file);
byte[] data = new byte[1024];
int len;
while((len = fis.read(data)) !=-1){
dos.write(data, 0, len);
}
socket.shutdownOutput();//告诉服务器，我发送完毕
} catch (Exception e) {
System.out.println("上传失败");
}finally{
fis.close();
dos.close();
}
//接收结果
BufferedReader br = new BufferedReader(new InputStreamReader(socket.getInputStream()));
String result = br.readLine();
System.out.println(result);
br.close();
socket.close();
input.close();
}
}
第四题
案例：模拟给全部同学群发“欢迎来到尚硅谷”
开发提示：使用UDP群发
package com.atguigu.test04;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;
public class Test04Send {
public static void main(String[] args)throws Exception {
//(1)先建立一个DatagramSocket
DatagramSocket ds = new DatagramSocket();
//(2)准备发送的数据
String str = "欢迎来到尚硅谷";
byte[] data = str.getBytes();
for (int i = 0; i <= 255; i++) {
//(3)把数据包装成一个数据报
//DatagramPacket(byte[] buf, int length, InetAddress address, int port)
/*
* 第一个参数：要发送的数据的字节数组
* 第二个参数：数组的长度
* 第三个参数：接收方的IP地址
* 第三个参数：接收方的端口号
*
* 好比发快递，需要填写接收方的IP和端口号
*/
InetAddress ip = InetAddress.getByName("192.168.11."+i);
int port = 8888;
DatagramPacket dp = new DatagramPacket(data,data.length,ip,port);
try {
//(4)发送数据报
//通过socket发送
ds.send(dp);
} catch (Exception e) {
}
}
//(5)断开
ds.close();
}
}
package com.atguigu.test04;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
public class Test04Receiver {
public static void main(String[] args)throws Exception {
//1、准备一个socket，用来接收消息
//接收方，先确定端口号，监听数据的端口号
//好比，要收到快递，需要先确定自己的地址和手机号，然后对方才能给你发
DatagramSocket ds = new DatagramSocket(8888);
//2、准备一个数据报，来接收数据
//DatagramPacket(byte[] buf, int length)
byte[] data = new byte[1024*64];//64K
DatagramPacket dp = new DatagramPacket(data,data.length);
//3、接收数据
ds.receive(dp);
//4、拆包裹
byte[] result = dp.getData();
int len = dp.getLength();//实际接收的数据的长度
System.out.println(new String(result,0,len));
//5、关闭
ds.close();
}
}
第二十一章
第一题
案例：用反射获取某个类的信息，并用反射使用某个类
开发提示：
1、声明一个类：com.atguigu.test01.demo.AtguiguDemo，
（1）包含静态变量：学校school（显式初始化为"尚硅谷"）
（2）包含属性：班级名称className
（3）并提供构造器，get/set等
（4）实现Serializable和Comparable接口（按照班级名称排序）
2、把com.atguigu.test01.demo.AtguiguDemoclass导出为一个atguigu.jar并放到D:\ProgramFiles\Java\jdk1.8.0_141\jre\lib\ext目录（注意，以你自己的JDK安装目录为准）
3、在测试类Test01的test01()测试方法中，用反射获取AtguiguDemo类的Class对象，并获取它的所有信息，包括类加载器、包名、类名、父类、父接口、属性、构造器、方法们等。
4、在测试类Test01的test02()测试方法中，用反射获取school的值，并修改school的值为“尚硅谷大学”，然后再获取school的值
5、在测试类Test01的test03()测试方法中，用反射创建AtguiguDemo类的对象，并设置班级名称className属性的值，并获取它的值
6、在测试类Test01的test04()测试方法中，用反射获取有参构造创建2个AtguiguDemo类的对象，并获取compareTo方法，调用compareTo方法，比较大小。
package com.atguigu.test01;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;
import java.lang.reflect.ParameterizedType;
import java.util.Arrays;
import org.junit.Test;
public class Test01 {
@Test
public void test01() throws ClassNotFoundException{
Class clazz = Class.forName("com.atguigu.test01.demo.AtguiguDemo");
ClassLoader classLoader = clazz.getClassLoader();
System.out.println("类加载器：" + classLoader);
Package pkg = clazz.getPackage();
System.out.println("包名：" + pkg.getName());
int cMod = clazz.getModifiers();
System.out.println("类的修饰符：" + Modifier.toString(cMod));
System.out.println("类名：" + clazz.getName());
System.out.println("父类：" + clazz.getSuperclass().getName());
Class[] interfaces = clazz.getInterfaces();
System.out.println("父接口们："+Arrays.toString(interfaces));
Field[] declaredFields = clazz.getDeclaredFields();
for (int i =0 ;i<declaredFields.length; i++) {
System.out.println("第" + (i+1) + "个字段：");
int fMod = declaredFields[i].getModifiers();
System.out.println("修饰符：" + Modifier.toString(fMod));
System.out.println("数据类型：" + declaredFields[i].getType().getName());
System.out.println("属性名：" + declaredFields[i].getName());
}
Constructor[] declaredConstructors = clazz.getDeclaredConstructors();
for (int i = 0; i < declaredConstructors.length; i++) {
System.out.println("第" + (i+1) + "个构造器：");
int csMod = declaredConstructors[i].getModifiers();
System.out.println("修饰符：" + Modifier.toString(csMod));
System.out.println("构造器名：" + declaredConstructors[i].getName());
System.out.println("形参列表：" + Arrays.toString(declaredConstructors[i].getParameterTypes()));
}
Method[] declaredMethods = clazz.getDeclaredMethods();
for (int i = 0; i < declaredMethods.length; i++) {
System.out.println("第" + (i+1) + "个成员方法：");
int csMod = declaredMethods[i].getModifiers();
System.out.println("修饰符：" + Modifier.toString(csMod));
System.out.println("返回值类型：" + declaredMethods[i].getReturnType().getName());
System.out.println("方法名：" + declaredMethods[i].getName());
System.out.println("形参列表：" + Arrays.toString(declaredMethods[i].getParameterTypes()));
}
}
@Test
public void test02() throws Exception{
Class clazz = Class.forName("com.atguigu.test01.demo.AtguiguDemo");
Field field = clazz.getDeclaredField("school");
field.setAccessible(true);
Object value = field.get(null);
System.out.println("school = " + value);
field.set(null, "尚硅谷大学");
value = field.get(null);
System.out.println("school = " + value);
}
@Test
public void test03() throws Exception{
Class clazz = Class.forName("com.atguigu.test01.demo.AtguiguDemo");
Object object = clazz.newInstance();
Field field = clazz.getDeclaredField("className");
field.setAccessible(true);
Object value = field.get(object);
System.out.println("className = " + value);
field.set(object, "190513班");
value = field.get(object);
System.out.println("className = " + value);
}
@Test
public void test04() throws Exception{
Class clazz = Class.forName("com.atguigu.test01.demo.AtguiguDemo");
Constructor c = clazz.getDeclaredConstructor(String.class);
Object obj1 = c.newInstance("190513BJ班");
Object obj2 = c.newInstance("190325SH班");
Method m = clazz.getDeclaredMethod("compareTo", Object.class);
System.out.println("obj1与obj2比较结果：" + m.invoke(obj1, obj2));
}
}
package com.atguigu.test01.demo;
import java.io.Serializable;
public class AtguiguDemo implements Serializable,Comparable<AtguiguDemo>{
private static final long serialVersionUID = 1L;
private static String school = "尚硅谷";
private String className;
public AtguiguDemo(String className) {
super();
this.className = className;
}
public AtguiguDemo() {
super();
}
public static String getSchool() {
return school;
}
public static void setSchool(String school) {
AtguiguDemo.school = school;
}
public String getClassName() {
return className;
}
public void setClassName(String className) {
this.className = className;
}
@Override
public String toString() {
return "AtguiguDemo [className=" + className + "]";
}
@Override
public int compareTo(AtguiguDemo o) {
return this.className.compareTo(o.getClassName());
}
}
第二题
案例：榨汁机(Juicer)榨汁的案例，分别有水果(Fruit)苹果(Apple)香蕉(Banana)桔子(Orange)榨汁(squeeze)
效果：
开发提示：
1、声明(Fruit)水果接口，包含榨汁抽象方法：void squeeze();
2、声明榨汁机(Juicer)，包含运行方法：public void run(Fruit f)，方法体中，调用f的榨汁方法squeeze()
3、声明各种水果类，实现(Fruit)水果接口，并重写squeeze();
4、在src下，建立配置文件：config.properties，并在配置文件中配上fruitName=xxx（其中xx为某种水果的全类名）
5、在Test02测试类中，
（1）读取配置文件，获取水果类名，并用反射创建水果对象，
（2）创建榨汁机对象，并调用run()方法
package com.atguigu.test02;
import java.util.Properties;
public class Test02 {
public static void main(String[] args) throws Exception {
Properties pro = new Properties();
pro.load(Test02.class.getClassLoader().getResourceAsStream("config.properties"));
Class<?> clazz = Class.forName(pro.getProperty("fruitName"));
Fruit f = (Fruit) clazz.newInstance();
Juicer j = new Juicer();
j.run(f);
}
}
interface Fruit {
public void squeeze();
}
class Juicer {
public void run(Fruit f) {
f.squeeze();
}
}
class Apple implements Fruit {
public void squeeze() {
System.out.println("榨出一杯苹果汁儿");
}
}
class Orange implements Fruit {
public void squeeze() {
System.out.println("榨出一杯桔子汁儿");
}
}
第三题
代码填空题
package com.atguigu.test03;
import java.lang.reflect.ParameterizedType;
public class Test03 {
public static void main(String[] args) {
SubA a = new SubA();
System.out.println(a.getType());
SubB b = new SubB();
System.out.println(b.getType());
}
}
abstract class Base<T>{
private Class type;
public Base(){
//为type属性赋值为T的实际类型
_____________________________________
}
public Class getType() {
return type;
}
}
class SubA extends Base<String>{
}
class SubB extends Base{
}package com.atguigu.test03;
import java.lang.reflect.ParameterizedType;
public class Test03 {
public static void main(String[] args) {
SubA a = new SubA();
System.out.println(a.getType());
SubB b = new SubB();
System.out.println(b.getType());
}
}
abstract class Base<T>{
private Class type;
public Base(){
Class<? extends Base> clazz = this.getClass();
try {
ParameterizedType pt = (ParameterizedType) clazz.getGenericSuperclass();
type = (Class) pt.getActualTypeArguments()[0];
} catch (Exception e) {
type = Object.class;
}
}
public Class getType() {
return type;
}
}
class SubA extends Base<String>{
}
class SubB extends Base{
}第四题
案例：
1、声明自定义注解@Table
（1）加上String类型的配置参数value
（2）并限定@Table的使用位置为类上
（3）并指定生命周期为“运行时”
2、声明自定义注解@Column
（1）加上String类型的配置参数name，表示表格的列名
（2）加上String类型的配置参数type，表示表格的列数据类型
（3）并限定@Column的使用位置在属性上
（4）并指定生命周期为“运行时”
3、声明User类，
（1）属性：id, username, password, email
（2）在User类上，标记@Table注解，并为value赋值为"t_user"
（3）在User类的每一个属性上标记@Column，并为name和type赋值，例如：
id：name赋值为no，type赋值为int
username：name赋值为username，type赋值为varchar(20)
password：name赋值为pwd，type赋值为char(6)
email：name赋值为email，type赋值为varchar(50)
4、在测试类Test04中，通过反射，获取User类以及每一个属性声明的注解，并获取注解值
运行效果：
package com.atguigu.test04;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
public @interface Table {
String value();
}
package com.atguigu.test04;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
public @interface Column {
String name();
String type();
}package com.atguigu.test04;
@Table("t_user")
public class User {
@Column(name="no",type="int")
private int id;
@Column(name="username",type="varchar(20)")
private String username;
@Column(name="pwd",type="char(6)")
private String password;
@Column(name="email",type="varchar(50)")
private String email;
public User(int id, String username, String password, String email) {
super();
this.id = id;
this.username = username;
this.password = password;
this.email = email;
}
public User() {
super();
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getUsername() {
return username;
}
public void setUsername(String username) {
this.username = username;
}
public String getPassword() {
return password;
}
public void setPassword(String password) {
this.password = password;
}
public String getEmail() {
return email;
}
public void setEmail(String email) {
this.email = email;
}
@Override
public String toString() {
return "User [id=" + id + ", username=" + username + ", password=" + password + ", email=" + email + "]";
}
}package com.atguigu.test04;
import java.lang.reflect.Field;
public class Test04 {
public static void main(String[] args) throws Exception {
Class clazz = User.class;
Table t = (Table) clazz.getAnnotation(Table.class);
String table = t.value();
System.out.println("User类对应数据库表：" + table);
Field idField = clazz.getDeclaredField("id");
Column idColumn = idField.getAnnotation(Column.class);
String idName = idColumn.name();
String idType = idColumn.type();
System.out.println("id属性对应数据库表的字段：" + idName + "，类型：" + idType);
Field usernameField = clazz.getDeclaredField("username");
Column usernameColumn = usernameField.getAnnotation(Column.class);
String usernameName = usernameColumn.name();
String usernameType = usernameColumn.type();
System.out.println("username属性对应数据库表的字段：" + usernameName + "，类型：" + usernameType);
Field passwordField = clazz.getDeclaredField("password");
Column passwordColumn = passwordField.getAnnotation(Column.class);
String passwordName = passwordColumn.name();
String passwordType = passwordColumn.type();
System.out.println("password属性对应数据库表的字段：" + passwordName + "，类型：" + passwordType);
Field emailField = clazz.getDeclaredField("email");
Column emailColumn = emailField.getAnnotation(Column.class);
String emailName = emailColumn.name();
String emailType = emailColumn.type();
System.out.println("email属性对应数据库表的字段：" + emailName + "，类型：" + emailType);
}
}
第二十二章
第一题
案例：
1、定义一个函数式接口CurrentTimePrinter,其中抽象方法void printCurrentTime()，使用注解@FunctionalInterface
2、在测试类中定义public static void showLongTime(CurrentTimePrinter timePrinter)，该方法的预期行为是使用timePrinter打印当前系统时间
3、测试showLongTime(),通过lambda表达式完成需求
（1）实现一：打印当前系统时间毫秒值，用System. currentTimeMillis()
（2）实现二：打印当前系统时间，用Date
（3）实现三：打印本地化当前系统时间，用LocalDateTime
package com.atguigu.test01;
import java.time.LocalDateTime;
import java.util.Date;
public class Test01 {
public static void main(String[] args) {
showLongTime(() -> System.out.println(System.currentTimeMillis()));
showLongTime(() -> System.out.println(new Date()));
showLongTime(() -> System.out.println(LocalDateTime.now()));
}
public static void showLongTime(CurrentTimePrinter timePrinter){
timePrinter.printCurrentTime();
}
}
@FunctionalInterface
interface CurrentTimePrinter{
void printCurrentTime();
}第二题
案例：
1、定义一个函数式接口IntCalc,其中抽象方法int cal(int a , int b)，使用注解@FunctionalInterface 2、在测试类中定义public static void getProduct(int a , int b ,IntCalc tools), 该方法的预期行为打印使用tools的cal(a,b)的计算结果 3、测试getProduct(),通过lambda表达式完成需求，其中a =1,b = 2
（1）实现一：求a,b的和
（2）实现二：求a,b的差
（3）实现三：求a,b的积
（4）实现四：求a,b的商
（5）实现五：求a,b的按位与
（6）实现六：求a<<b
package com.atguigu.test02;
public class Test02 {
public static void main(String[] args) {
getProduct(1,2,(a,b) -> a+b);
getProduct(1,2,(a,b) -> a-b);
getProduct(1,2,(a,b) -> a*b);
getProduct(1,2,(a,b) -> a/b);
getProduct(1,2,(a,b) -> a&b);
getProduct(1,2,(a,b) -> a<<b);
}
public static void getProduct(int a , int b ,IntCalc tools){
System.out.println("结果：" + tools.cal(a, b));
}
}
@FunctionalInterface
interface IntCalc{
int cal(int a , int b);
}第三题
案例：
1、给出测试类代码如下：
package com.atguigu.test03;
import java.util.function.Supplier;
public class Test03 {
public static <T> T getObj(Supplier<T> supplier) {
return supplier.get();
}
public static void main(String[] args) {
....
}
}
2、分别使用lambda表达式获得以下对象：
-
长度为5的String数组
-
包含5个1-20(含1和20)之间随机数的HashSet<Integer>集合
-
一个代表2018年4月1日的Calendar对象
package com.atguigu.test03;
import java.util.Arrays;
import java.util.GregorianCalendar;
import java.util.HashSet;
import java.util.Random;
import java.util.function.Supplier;
public class Test03 {
public static <T> T getObj(Supplier<T> supplier) {
return supplier.get();
}
public static void main(String[] args) {
String[] arr = getObj(() -> new String[5]);
System.out.println(Arrays.toString(arr));
Random rand = new Random();
HashSet<Integer> nums = getObj(() -> {
HashSet<Integer> set = new HashSet<Integer>();
while(set.size()<5){
set.add(rand.nextInt(20)+1);
}
return set;
});
System.out.println(nums);
GregorianCalendar obj = getObj(() -> new GregorianCalendar(2019,5,13));
System.out.println(obj);
}
}
第四题
案例：
1、给出测试类代码如下：
package com.atguigu.test04;
import java.util.HashMap;
import java.util.function.Consumer;
public class Test04 {
public static <T> void doJob(T t, Consumer<T> consumer) {
consumer.accept(t);
}
public static <T> void doJob(T t, Consumer<T> consumer1, Consumer<T> consumer2) {
consumer1.andThen(consumer2).accept(t);
}
public static void main(String[] args) {
HashMap<String, Integer> map = new HashMap<>();
// key:姓名 value:成绩
map.put("岑小村", 59);
map.put("谷天洛", 82);
map.put("渣渣辉", 98);
map.put("蓝小月", 65);
map.put("皮几万", 70);
}
}2、分别使用lambda表达式完成以下需求
-
打印谷天洛的分数
-
打印最高分
-
分别以60分和70分为及格线，打印及格的人的名字(组合型消费)
package com.atguigu.test04;
import java.util.Collections;
import java.util.HashMap;
import java.util.Map;
import java.util.function.Consumer;
public class Test04 {
public static <T> void doJob(T t, Consumer<T> consumer) {
consumer.accept(t);
}
public static <T> void doJob(T t, Consumer<T> consumer1, Consumer<T> consumer2) {
consumer1.andThen(consumer2).accept(t);
}
public static void main(String[] args) {
HashMap<String, Integer> map = new HashMap<>();
// key:姓名 value:成绩
map.put("岑小村", 59);
map.put("谷天洛", 82);
map.put("渣渣辉", 98);
map.put("蓝小月", 65);
map.put("皮几万", 70);
//打印谷天洛的分数
doJob(map, (m) -> System.out.println("谷天洛的分数：" + m.get("谷天洛")));
//打印最高分
doJob(map, (m) -> System.out.println("最高分：" + Collections.max(m.values())));
//打印及格的人的名字
doJob(map, (m) -> {
System.out.print("60分及格的人：");
for (Map.Entry<String, Integer> entry : m.entrySet()) {
if (entry.getValue()>=60){
System.out.print(entry.getKey()+" ");
}
}
System.out.println();
}, (m) -> {
System.out.print("70分及格的人：");
for (Map.Entry<String, Integer> entry : m.entrySet()) {
if (entry.getValue()>=70){
System.out.print(entry.getKey()+" ");
}
}
System.out.println();
});
}
}
第五题
案例：
1、定义学生类: （1）成员变量 姓名：String name; （2）成员变量 成绩：int score； （3）无参及全参构造 （4）重写toString()
2、在测试类中完成如下要求 （1）将五名学生添加到ArrayList集合 （2）使用Collections.sort(List<T> list, Comparator<? super T> c)方法将学生成绩从小到大进行排序，分别使用以下三种形式实现： a、使用匿名内部类 b、使用Lambda表达式 c、使用方法引用 //tips:借助Comparator接口中静态方法comparingInt()方法
3、学生信息与成绩如下：
| 姓名 | 数学 |
|---|---|
| 谢霆锋 | 85 |
| 章子怡 | 63 |
| 刘亦菲 | 77 |
| 黄晓明 | 33 |
| 岑小村 | 92 |
package com.atguigu.test05;
public class Student {
private String name;
private int score;
public Student() {
}
public Student(String name, int score) {
this.name = name;
this.score = score;
}
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;
}
@Override
public String toString() {
return "Student{" + "name='" + name + '\'' + ", score=" + score + '}';
}
}package com.atguigu.test05;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
public class Test05 {
public static void main(String[] args) {
ArrayList<Student> list = new ArrayList<>();
list.add(new Student("谢霆锋", 85));
list.add(new Student("章子怡", 63));
list.add(new Student("刘亦菲", 77));
list.add(new Student("黄晓明", 33));
list.add(new Student("岑小村", 92));
// 使用匿名内部类将成绩从小到大排序
Collections.sort(list, new Comparator<Student>() {
@Override
public int compare(Student o1, Student o2) {
return o1.getScore() - o2.getScore();
}
});
// 使用Lambda为英语成绩从小到大排序
Collections.sort(list, (o1, o2) -> o1.getScore() - o2.getScore());
// 借助comparingInt()使用方法引用
Collections.sort(list, Comparator.comparingInt(Student::getScore));
System.out.println(list);
}
}
第六题
案例：
1、声明一个员工类型Employee，包含编号、姓名、薪资、年龄、性别
2、声明一个员工管理类，
（1）管理类中使用ArrayList，来存储所有员工对象
（2）声明public void add(Employee emp)方法，添加员工
（3）声明public ArrayList get(Predicate<Employee> p)方法，可以根据条件筛选出符合要求的员工
（4）声明public void remove(Predicate<Employee> p)方法，可以根据条件删除
（5）声明public void update(Consumer<Employee> c)方法，对集合中的元素执行c指定的操作
3、在测试类
（1）添加5个员工对象到管理的集合中
（2）筛选出
①编号是偶数的员工
②薪资低于10000的员工
③年龄大于30岁的女员工
④姓张的员工
⑤所有员工
（3）删除
①年龄大于30岁的女员工
②删除“张三”这个员工
（4）给每个员工涨薪10%
package com.atguigu.test06;
public class Employee {
private int id;
private String name;
private double salary;
private int age;
private char gender;
public Employee(int id, String name, double salary, int age, char gender) {
super();
this.id = id;
this.name = name;
this.salary = salary;
this.age = age;
this.gender = gender;
}
public Employee() {
super();
}
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 double getSalary() {
return salary;
}
public void setSalary(double salary) {
this.salary = salary;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public char getGender() {
return gender;
}
public void setGender(char gender) {
this.gender = gender;
}
@Override
public String toString() {
return "Employee [id=" + id + ", name=" + name + ", salary=" + salary + ", age=" + age + ", gender=" + gender
+ "]";
}
}
package com.atguigu.test06;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.function.Consumer;
import java.util.function.Predicate;
public class EmployeeService {
private ArrayList<Employee> list;
public EmployeeService(){
list = new ArrayList<Employee>();
}
public void add(Employee emp){
list.add(emp);
}
public ArrayList<Employee> get(Predicate<Employee> p){
ArrayList<Employee> all = new ArrayList<Employee>();
for (Employee employee : list) {
if(p.test(employee)){
all.add(employee);
}
}
return all;
}
public void remove(Predicate<Employee> p){
Iterator<Employee> iterator = list.iterator();
while(iterator.hasNext()){
Employee next = iterator.next();
if(p.test(next)){
iterator.remove();
}
}
}
public void update(Consumer<Employee> c){
for (Employee employee : list) {
c.accept(employee);
}
}
public int size(){
return list.size();
}
}
package com.atguigu.test06;
import java.util.ArrayList;
import org.junit.After;
import org.junit.BeforeClass;
import org.junit.Test;
public class Test06 {
private static EmployeeService es = new EmployeeService();
@BeforeClass
public static void test01(){
es.add(new Employee(1, "张三", 8000, 23, '男'));
es.add(new Employee(2, "王小二", 12000, 22, '男'));
es.add(new Employee(3, "李四", 12000, 24, '女'));
es.add(new Employee(4, "王五", 11000, 34, '女'));
es.add(new Employee(5, "赵六", 6000, 34, '女'));
}
@Test
public void testSize(){
System.out.println("目前员工数量：" + es.size());
}
@Test
public void testRemove1(){
//删除年龄大于30岁的女员工
System.out.println("删除年龄大于30岁的女员工");
es.remove(e->e.getAge()>30 && e.getGender()=='女');
}
@Test
public void testRemove2(){
//删除“张三”这个员工
System.out.println("删除“张三”这个员工");
es.remove(e->e.getName().startsWith("张"));
}
@Test
public void testRemove3(){
System.out.println("每个人涨薪资10%");
es.update(e -> e.setSalary(e.getSalary()*1.1));
}
@After
public void test(){
System.out.println("编号是偶数的员工有：");
ArrayList<Employee> list1 = es.get(e->e.getId()%2==0);
for (Employee employee : list1) {
System.out.println(employee);
}
System.out.println("薪资低于10000的员工有：");
ArrayList<Employee> list2 = es.get(e->e.getSalary()<10000);
for (Employee employee : list2) {
System.out.println(employee);
}
System.out.println("年龄大于30岁的女员工有：");
ArrayList<Employee> list3 = es.get(e->e.getAge()>30 && e.getGender()=='女');
for (Employee employee : list3) {
System.out.println(employee);
}
System.out.println("姓张的员工有：");
ArrayList<Employee> list4 = es.get(e->e.getName().startsWith("张"));
for (Employee employee : list4) {
System.out.println(employee);
}
System.out.println("所有员工有：");
ArrayList<Employee> list5 = es.get(e -> true);
for (Employee employee : list5) {
System.out.println(employee);
}
System.out.println();
}
}
第七题
案例：
1、已知学生成绩如下
| 姓名 | 成绩 |
|---|---|
| 岑小村 | 59 |
| 谷天洛 | 82 |
| 渣渣辉 | 98 |
| 蓝小月 | 65 |
| 皮几万 | 70 |
以学生姓名为key成绩为value创建集合并存储数据
2、使用lambda表达式分别将以下功能封装到Function对象中
（1）将Map<String,Integer>中value存到ArrayList<Integer>中
（2）求Integer类型ArrayList中所有元素的平均数
3、使用Function对象求学生的平均值
package com.atguigu.test07;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Map;
import java.util.function.Function;
public class Test07 {
public static void main(String[] args) {
// 将学生姓名和成绩封装到map中
HashMap<String,Integer> map = new HashMap<String, Integer>();
map.put("岑小村", 59);
map.put("谷天洛", 82);
map.put("渣渣辉", 98);
map.put("蓝小月", 65);
map.put("皮几万", 70);
// 将Map<String,Integer>中value存到ArrayList<Integer>中
Function<Map<String,Integer>,ArrayList<Integer>> f1 = (m)->{
ArrayList<Integer> list = new ArrayList<>();
list.addAll(m.values());
return list;
};
// 求Integer类型ArrayList中所有元素的平均数
Function<ArrayList<Integer>,Double> f2 = (list)->{
double sum = 0;
for (Integer i : list) {
sum+=i;
}
return sum/list.size();
};
//利用Function求平均成绩
Double avg = f1.andThen(f2).apply(map);
System.out.println("学生平均成绩为："+avg);
}
}
第八题
现在有两个 ArrayList 集合存储队伍当中的多个成员姓名，
List<String> one = new ArrayList<>();
one.add("清风");
one.add("陈玄风");
one.add("梅超风");
one.add("陆乘风");
one.add("曲灵风");
one.add("武眠风");
one.add("冯默风");
one.add("罗玉风");
List<String> two = new ArrayList<>();
two.add("宋远桥");
two.add("俞莲舟");
two.add("俞岱岩");
two.add("张松溪");
two.add("张翠山");
two.add("殷梨亭");
two.add("张声谷");
要求使用Stream方式进行以下若干操作步骤：
-
第一个队伍只要名字为3个字的成员姓名；
-
第一个队伍筛选之后只要前4个人；
-
第二个队伍只要姓张的成员姓名；
-
第二个队伍筛选之后不要前1个人；
-
将两个队伍合并为一个队伍；
-
根据姓名创建Student对象；Student类型包含name属性
-
打印整个队伍的Student对象信息。
package com.atguigu.test08;
import java.util.ArrayList;
import java.util.List;
import java.util.stream.Stream;
public class Test08 {
public static void main(String[] args) {
List<String> one = new ArrayList<>();
one.add("清风");
one.add("陈玄风");
one.add("梅超风");
one.add("陆乘风");
one.add("曲灵风");
one.add("武眠风");
one.add("冯默风");
one.add("罗玉风");
List<String> two = new ArrayList<>();
two.add("宋远桥");
two.add("俞莲舟");
two.add("俞岱岩");
two.add("张松溪");
two.add("张翠山");
two.add("殷梨亭");
two.add("张声谷");
// 第一个队伍只要名字为3个字的成员姓名；
// 第一个队伍筛选之后只要前4个人；
Stream<String> streamOne = one.stream().filter(s -> s.length() == 3).limit(6);
// 第二个队伍只要姓张的成员姓名；
// 第二个队伍筛选之后不要前1个人；
Stream<String> streamTwo = two.stream().filter(s -> s.startsWith("张")).skip(1);
// 将两个队伍合并为一个队伍；
// 根据姓名创建Student对象；
// 打印整个队伍的Student对象信息。
Stream.concat(streamOne, streamTwo).map(Student::new).forEach(System.out::println);
}
}
class Student {
private String name;
public Student() {
}
public Student(String name) {
this.name = name;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
@Override
public String toString() {
return " Student {name='" + name + "'}";
}
}
第九题
案例：
以下是某不知名机构评出的全球最佳影片及华人最佳影片前十名 ：
全球 1、 《教父》 2、 《肖申克的救赎》 3、 《辛德勒的名单》 4、 《公民凯恩》 5、 《卡萨布兰卡》 6、 《教父续集》 7、 《七武士》 8、 《星球大战》 9、 《美国美人》 10、 《飞跃疯人院》
华人
1、 《霸王别姬》 2、 《大闹天宫》 3、 《鬼子来了》 4、 《大话西游》 5、 《活着》 6、 《饮食男女》 7、 《无间道》 8、 《天书奇谭》 9、 《哪吒脑海》 10、 《春光乍泄》
1、现将两个榜单中的影片名，分别按排名顺序依次存入两个ArrayList集合
2、通过流的方式
1）打印全球影片排行榜中的前三甲影片名
2）打印华人影片排行榜中倒数5名的影片名
3）将两个排行榜中的前5名挑出来共同存入新的集合
4）定义电影Film类，以影片名为name创建Film对象并保存至集合，Film类型包含影片名属性
package com.atguigu.test09;
import java.util.ArrayList;
import java.util.List;
import java.util.stream.Collectors;
import java.util.stream.Stream;
public class Test09 {
public static void main(String[] args) {
// 将原始数据存入集合
ArrayList<String> global = new ArrayList<>();
global.add("《教父》");
global.add("《肖申克的救赎》");
global.add("《辛德勒的名单》");
global.add("《公民凯恩》");
global.add("《卡萨布兰卡》");
global.add("《教父续集》");
global.add("《七武士》");
global.add("《星球大战》");
global.add("《美国美人》");
global.add("《飞跃疯人院》");
ArrayList<String> china = new ArrayList<>();
china.add("《霸王别姬》");
china.add("《大闹天宫》");
china.add("《鬼子来了》");
china.add("《大话西游》");
china.add("《活着》");
china.add("《饮食男女》");
china.add("《无间道》");
china.add("《天书奇谭》");
china.add("《哪吒脑海》");
china.add("《春光乍泄》");
// 1）打印全球影片排行榜中的前三甲影片名
global.stream().limit(3).forEach(System.out::println);
System.out.println();
// 2）打印华人影片排行榜中倒数5名的影片名
china.stream().skip(china.size() - 5).forEach(System.out::println);
System.out.println();
// 3）将两个排行榜中的前5名挑出来共同存入新的集合
List<String> list = Stream.concat(global.stream().limit(5), china.stream().limit(5))
.collect(Collectors.toList());
for (String string : list) {
System.out.println(string);
}
System.out.println();
// 4）将所有影片以影片名为name创建Film对象并保存至集合
List<Film> filmList = Stream.concat(global.stream(), china.stream()).map(Film::new)
.collect(Collectors.toList());
for (Film film : filmList) {
System.out.println(film);
}
}
}
class Film {
private String name;
public Film() {
}
public Film(String name) {
this.name = name;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
@Override
public String toString() {
return "Film [name=" + name + "]";
}
}
第十题
我国有34个省级行政区，分别是：
23个省：
河北省、山西省、吉林省、辽宁省、黑龙江省、陕西省、甘肃省、青海省、山东省、福建省、浙江省、台湾省、河南省、湖北省、湖南省、江西省、江苏省、安徽省、广东省、海南省、四川省、贵州省、云南省。
4个直辖市：
北京市、天津市、上海市、重庆市。
5个自治区：
内蒙古自治区、新疆维吾尔自治区、[夏回族自治区、广西壮族自治区、西藏自治区
2个特别行政区：
香港特别行政区、澳门特别行政区
使用流：
1、统计三个字的省份的个数
2、统计名字中包含方位名词的省份（东西南北）的个数
3、打印名字中包含方位名词的普通省份（非自治区直辖市特别行政区）的名字
4、将所有的特殊省份（自治区直辖市特别行政区）提取出来并放到新数组中
package com.atguigu.test10;
import java.util.Arrays;
import java.util.stream.Stream;
public class Test10 {
public static void main(String[] args) {
String[] provinces = { "河北省", "山西省", "吉林省", "辽宁省", "黑龙江省", "陕西省", "甘肃省", "青海省", "山东省", "福建省", "浙江省", "台湾省",
"河南省", "湖北省", "湖南省", "江西省", "江苏省", "安徽省", "广东省", "海南省", "四川省", "贵州省", "云南省", "北京市", "天津市", "上海市", "重庆市",
"内蒙古自治区", "新疆维吾尔自治区", "宁夏回族自治区", "广西壮族自治区", "西藏自治区", "香港特别行政区", "澳门特别行政区" };
// 1、统计三个字的省份的个数
long threeCount = Stream.of(provinces).filter(s -> s.length() == 3).count();
System.out.println("三个字的省份的个数：" + threeCount);
// 2、统计名字中包含方位名词的省份（东西南北）的个数
long count = Stream.of(provinces)
.filter(s -> s.contains("东") || s.contains("西") || s.contains("南") || s.contains("北")).count();
System.out.println("包含方位名词的省份（东西南北）的个数:" + count);
// 3、打印名字中包含方位名词的普通省份（非自治区直辖市特别行政区）的名字
System.out.println("包含方位名词的普通省份有：");
Stream.of(provinces).filter(s -> s.contains("东") || s.contains("西") || s.contains("南") || s.contains("北"))
.filter(s -> s.contains("省")).forEach(System.out::println);
// 4、将所有的特殊省份（自治区直辖市特别行政区）提取出来并放到新数组中
String[] pros = Stream.of(provinces).filter(s -> !s.contains("省")).toArray(String[]::new);
System.out.println("新数组:" + Arrays.toString(pros));
}
}
431
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
