xx/javaSE1001
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

init

Browse Source
This commit is contained in:
xuxin
2025-12-21 17:24:54 +08:00
commit e8c50a3d78
660 changed files with 29599 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

24
s_day03/src/com/inmind/collections_04/Demo01.java Normal file
View File

@@ -0,0 +1,24 @@
package com.inmind.collections_04;
import java.util.ArrayList;
import java.util.Collections;
/*
Collections的常用方法
static <T> boolean addAll(Collection<? super T> c, T... elements) 将所有指定的元素添加到指定的集合。
static void shuffle(List<?> list) 使用默认的随机源随机排列指定的列表。
*/
public class Demo01 {
public static void main(String[] args) {
ArrayList<String> list = new ArrayList<String>();
/*list.add("A");
list.add("B");
list.add("C");*/
Collections.addAll(list, "刘备", "关羽", "张飞", "吕布", "曹操");
System.out.println(list);
Collections.shuffle(list);
System.out.println(list);
}
}

37
s_day03/src/com/inmind/collections_04/Demo02.java Normal file
View File

@@ -0,0 +1,37 @@
package com.inmind.collections_04;
import java.util.ArrayList;
import java.util.Collections;
/*
static <T extends Comparable<? super T>> void sort(List<T> list) 根据其元素的自然排序，按照升序排列指定的列表。
*/
public class Demo02 {
public static void main(String[] args) {
//整数的自然排序：默认升序
ArrayList<Integer> lists = new ArrayList<>();
Collections.addAll(lists, 100, 29, 13, 44, 35, 56);
System.out.println(lists);
Collections.sort(lists);
System.out.println(lists);
System.out.println("--------------------------------------");
//字符串的自然排序:默认升序，按照每个字符的ASCII码表的十进制的值来排序
ArrayList<String> lists1 = new ArrayList<>();
Collections.addAll(lists1, "ba", "aa", "ab", "ca");
System.out.println(lists1);
Collections.sort(lists1);
System.out.println(lists1);
System.out.println("-------------------自定义对象排序-------------------");
ArrayList<Student> students = new ArrayList<>();
Student s1 = new Student("张三", 18);
Student s2 = new Student("李四", 19);
Student s3 = new Student("王五", 20);
Collections.addAll(students, s1, s2, s3);
System.out.println(students);
//注意：Collections.sort排序时，传入的集合的内容，必须拥有自然排序功能（实现Comparable）
Collections.sort(students);
System.out.println(students);
}
}

63
s_day03/src/com/inmind/collections_04/Demo03.java Normal file
View File

@@ -0,0 +1,63 @@
package com.inmind.collections_04;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
/*
18.比较器Comparetor的使用
static <T> void sort(List<T> list, Comparator<? super T> c) 根据指定的比较器引起的顺序对指定的列表进行排序。
当集合中保存的数据不具有自然排序功能或者它原本的自然排序功能不满足我们的需求，就可以使用比较器来添加或者覆盖排序效果
*/
public class Demo03 {
public static void main(String[] args) {
ArrayList<Person> list = new ArrayList<>();
Person s1 = new Person("张三", 18,80);
Person s2 = new Person("李四", 19,80);
Person s3 = new Person("王五", 20,99);
Collections.addAll(list, s1, s3, s2);
System.out.println(list);
Collections.sort(list, new Comparator<Person>() {
@Override
public int compare(Person o1, Person o2) {
/* //按年龄排序升序：我(o1)-它(o2)
// return o1.age - o2.age;
////按年龄排序降序：它(o2)-我(o1)
return o2.age - o1.age;*/
//先按成绩降序排，如果成绩相同，才按年龄升序排
// int compare = Integer.compare(o2.score, o1.score);
int compare = o1.score - o2.score;
if (compare != 0) {
return compare;
}else{
//成绩相同，按年龄升序排
// return Integer.compare(o1.age, o2.age);
return o2.age- o1.age;
}
}
});
System.out.println(list);
System.out.println("-----------------------------------------");
ArrayList<Student> students = new ArrayList<>();
Student ss1 = new Student("张三", 18);
Student ss2 = new Student("李四", 19);
Student ss3 = new Student("王五", 20);
Collections.addAll(students, ss1, ss2, ss3);
System.out.println(students);
//注意：Collections.sort排序时，传入的集合的内容，必须拥有自然排序功能（实现Comparable）
//默认按照按年龄排降序排序，但是我不好默认的降序，我使用新的比较器降原本的自然排序功能覆盖要改为升序（框架思想：接口回调）
Collections.sort(students, new Comparator<Student>() {
@Override
public int compare(Student o1, Student o2) {
return o1.age - o2.age;
}
});
System.out.println(students);
}
}

22
s_day03/src/com/inmind/collections_04/Demo04.java Normal file
View File

@@ -0,0 +1,22 @@
package com.inmind.collections_04;
import java.util.ArrayList;
import java.util.Collections;
/*
static <T> int binarySearch(List<? extends T> list, T key, Comparator<? super T> c) 使用二叉搜索算法搜索指定对象的指定列表。
static <T> int binarySearch(List<? extends T> list, T key) 使用二叉搜索算法搜索指定对象的指定列表。
注意：由于采用二分法快速查找，所以它是基于排序之后的查询，必须先升序排序
*/
public class Demo04 {
public static void main(String[] args) {
ArrayList<Integer> list = new ArrayList<>();
Collections.addAll(list, 1, 2, 4, 10, 5, 6, 9, 8, 3);
System.out.println(list);
Collections.sort(list);
int index = Collections.binarySearch(list, 5);
System.out.println(list);
System.out.println(index);
}
}

38
s_day03/src/com/inmind/collections_04/Person.java Normal file
View File

@@ -0,0 +1,38 @@
package com.inmind.collections_04;
import java.util.Objects;
public class Person {
String name;
int age;
int score;
public Person(String name, int age, int score) {
this.name = name;
this.age = age;
this.score = score;
}
@Override
public boolean equals(Object o) {
if (!(o instanceof Person)) return false;
Person student = (Person) o;
return age == student.age && Objects.equals(name, student.name);
}
@Override
public int hashCode() {
return Objects.hash(name, age);
}
@Override
public String toString() {
return "Person{" +
"name='" + name + '\'' +
", age=" + age +
", score=" + score +
'}';
}
}

49
s_day03/src/com/inmind/collections_04/Student.java Normal file
View File

@@ -0,0 +1,49 @@
package com.inmind.collections_04;
import java.util.Objects;
public class Student implements Comparable<Student>{
String name;
int age;
public Student(String name, int age) {
this.name = name;
this.age = age;
}
@Override
public boolean equals(Object o) {
if (!(o instanceof Student)) return false;
Student student = (Student) o;
return age == student.age && Objects.equals(name, student.name);
}
@Override
public int hashCode() {
return Objects.hash(name, age);
}
@Override
public String toString() {
return "Student{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
//学生类的自然排序功能
/*
负整数，零或正整数，因为该对象(this)小于，等于或大于指定对象(参数o)。
口诀：
我-它：升序
它-我：降序
*/
@Override
public int compareTo(Student o) {
//按年龄排序，升序
// return this.age - o.age;
//按年龄排序，降序
return o.age - this.age;
}
}

32
s_day03/src/com/inmind/list_01/Demo01.java Normal file
View File

@@ -0,0 +1,32 @@
package com.inmind.list_01;
import java.util.ArrayList;
import java.util.List;
/*
List接口的特点：
1.存取有序
2.有索引
3.可以重复
List接口的常用实现类
ArrayList LinkedList
List接口是Collection的子接口，前天学习的单列集合API是都能使用
*/
public class Demo01 {
public static void main(String[] args) {
//List接口的多态
List<String> lists = new ArrayList<String>();
lists.add("刘备");
lists.add("关羽");
lists.add("张飞");
lists.add("关羽");
String s = lists.get(2);
System.out.println(s);
System.out.println(lists);
}
}

44
s_day03/src/com/inmind/list_01/Demo02.java Normal file
View File

@@ -0,0 +1,44 @@
package com.inmind.list_01;
import java.util.ArrayList;
import java.util.List;
/*
2.List接口的常用方法
List既拥有Collection的共有方法，也有它自己独有的功能，有序集合，有索引相关的增删改查操作
索引相关的增删改查API
public void add(int index, E element) : 将指定的元素，添加到该集合中的指定位置上。
public E get(int index) :返回集合中指定位置的元素。
public E remove(int index) : 移除列表中指定位置的元素, 返回的是被移除的元素。
public E set(int index, E element) :用指定元素替换集合中指定位置的元素,返回值的更新前的元素。
*/
public class Demo02 {
public static void main(String[] args) {
//list接口的多态
List<String> lists = new ArrayList<String>();
lists.add("刘备");
lists.add("关羽");
lists.add("张飞");
System.out.println(lists);
//public void add(int index, E element) : 将指定的元素，添加到该集合中的指定位置上 （插队）
//吕布插入到张飞之前
lists.add(2, "吕布");
System.out.println(lists);
//public E get(int index) :返回集合中指定位置的元素。
System.out.println(lists.get(3));
//public E remove(int index) : 移除列表中指定位置的元素, 返回的是被移除的元素。
String removedStr = lists.remove(2);
System.out.println(removedStr);
System.out.println(lists);
//public E set(int index, E element) :用指定元素替换集合中指定位置的元素,返回值的更新前的旧元素。
//把关羽修改为关二哥
String updatedStr = lists.set(1, "关二哥");
System.out.println(updatedStr);
System.out.println(lists);
}
}

25
s_day03/src/com/inmind/list_01/Demo03.java Normal file
View File

@@ -0,0 +1,25 @@
package com.inmind.list_01;
import java.util.ArrayList;
import java.util.List;
/*
List接口的实现类----ArrayList类的特点
它的底层是Object[]
它的特点：
1.查询快 （连续空间）
2.增删慢 （固定长度）
3.存取有序
4.有索引
5.数据可以重复
*/
public class Demo03 {
public static void main(String[] args) {
ArrayList<String> lists = new ArrayList<String>();
lists.add("刘备");
lists.add("关羽");
lists.add("张飞");
System.out.println(lists);
}
}

63
s_day03/src/com/inmind/list_01/Demo04.java Normal file
View File

@@ -0,0 +1,63 @@
package com.inmind.list_01;
import java.util.ArrayList;
import java.util.LinkedList;
/*
LinkedList的特点和基本使用
LinkedList是List接口的实现类，它的集合特点： 存取有序，有索引数据，可以重复
LinkedList底层数据结构是双向链表，它的数据结构的特点：1.查询慢 2.增删快
注意：当对很多数据要进行增删操作时，而不是就用来查询，那就使用LinkedList，反之ArrayList
-------------------------------------------------
LinkedList底层采用双向链表,它对于头尾操作的效率较高,所以该类提供了高效头尾操作的api
8.LinkedList独有的方法
public void addFirst(E e) :将指定元素插入此列表的开头。
public void addLast(E e) :将指定元素添加到此列表的结尾。
public E getFirst() :返回此列表的第一个元素。
public E getLast() :返回此列表的最后一个元素。
public E removeFirst() :移除并返回此列表的第一个元素。
public E removeLast() :移除并返回此列表的最后一个元素。
//模仿栈结构的api(操作双向链表的第一个数据)
public E pop() :从此列表所表示的堆栈处弹出一个元素。
public void push(E e) :将元素推入此列表所表示的堆栈。
*/
public class Demo04 {
public static void main(String[] args) {
LinkedList<String> lists = new LinkedList<String>();
lists.add("刘备");
lists.add("关羽");
lists.add("张飞");
System.out.println(lists);
System.out.println("-------------------独有方法------------------------");
//public void addFirst(E e) :将指定元素插入此列表的开头。
//public void addLast(E e) :将指定元素添加到此列表的结尾。
lists.addFirst("孙权");
lists.addLast("周瑜");
System.out.println(lists);
//public E getFirst() :返回此列表的第一个元素。
//public E getLast() :返回此列表的最后一个元素。
System.out.println(lists.getFirst());
System.out.println(lists.getLast());
//public E removeFirst() :移除并返回此列表的第一个元素。
//public E removeLast() :移除并返回此列表的最后一个元素。
System.out.println(lists.removeFirst());
System.out.println(lists.removeLast());
System.out.println(lists);
//public E pop() :从此列表所表示的堆栈处弹出一个元素。(removeFirst())
//public void push(E e) :将元素推入此列表所表示的堆栈。(addFirst())
System.out.println(lists.pop());
System.out.println(lists);
lists.push("刘备");
System.out.println(lists);
}
}

29
s_day03/src/com/inmind/set_02/Demo01.java Normal file
View File

@@ -0,0 +1,29 @@
package com.inmind.set_02;
import java.util.HashSet;
import java.util.Set;
/*
Set接口是Collection接口的子接口，它拥有Collection的所有功能
Set接口的特点：
1.存取无序（怎么存不一定怎么取）
2.没有索引
3.不能重复
Set接口的常用实现类：
HashSet LinkedHashSet
*/
public class Demo01 {
public static void main(String[] args) {
//set多态
Set<String> sets = new HashSet<>();
sets.add("张飞");
sets.add("刘备");
sets.add("关羽");
sets.add("关羽");
sets.add("关羽");
sets.add("关羽");
System.out.println(sets);
}
}

39
s_day03/src/com/inmind/set_02/Demo02.java Normal file
View File

@@ -0,0 +1,39 @@
package com.inmind.set_02;
import java.util.*;
/*
10.HashSet特点以及遍历
HashSet接口的特点：
1.存取无序（怎么存不一定怎么取）
2.没有索引
3.不能重复
HashSet底层数据结构是哈希表，就是一个HashMap
*/
public class Demo02 {
public static void main(String[] args) {
HashSet<String> sets = new HashSet<>();
sets.add("张飞");
sets.add("刘备");
sets.add("关羽");
System.out.println(sets);
//Set集合没有get方法，数据如何获取？？？只能通过迭代器数据，或者转为数组，之后的stream流操作
//迭代器遍历:获取迭代器，如果有，就拿数据
Iterator<String> iterator = sets.iterator();
while (iterator.hasNext()) {
String element = iterator.next();
System.out.println(element);
}
System.out.println("---------------------");
//foreach遍历，底层就是迭代器
for (String element : sets) {
System.out.println(element);
}
System.out.println("-----------转数组------------");
Object[] array = sets.toArray();
System.out.println(Arrays.toString(array));
}
}

34
s_day03/src/com/inmind/set_02/Demo03.java Normal file
View File

@@ -0,0 +1,34 @@
package com.inmind.set_02;
/*
1.什么是哈希值？？？
哈希值就是对象的特征码，使用十进制int来表示的，int是取值范围的，有限的，对象是无限。（不同的对象的哈希值可能相同的）
2.如何获取一个对象的哈希值？？？
int hashCode() 返回对象的哈希码值。
Object的hashCode源码：
public native int hashCode();//通过真正的地址值，使用哈希算法，返回的一个int值
3.我们发现每个对象的哈希值都是默认通过地址来获取，对于程序员来说没有意义，我们在实际开发中
希望拥有相同的内容的对象是同一个对象（哈希值要一样），所以我们子类重写hashCode方法，在判断
时使用到的哈希值要保持一致。
如何重写？？学习一个最终类 String,得出String的哈希值跟它的内容有关，那么自定义的类重写
hashCode方法，那么也跟自己的属性有关,alt+insert
*/
public class Demo03 {
public static void main(String[] args) {
Student s1 = new Student("刘备", 10);
Student s2 = new Student("刘备", 10);
String s;
int i = s1.hashCode();
System.out.println(i);
System.out.println(s1);
int i2 = s2.hashCode();
System.out.println(i2);
System.out.println(s2);
}
}

32
s_day03/src/com/inmind/set_02/Demo04.java Normal file
View File

@@ -0,0 +1,32 @@
package com.inmind.set_02;
import java.util.HashSet;
/*
Set集合底层的数据结构是哈希表
jdk8之前，数组+链表组成哈希表
jdk8之后，数组+链表+红黑树组成哈希表
*/
public class Demo04 {
public static void main(String[] args) {
String str1 = "abc";
String str2 = new String("abc");
String str3 = "通话";
String str4 = "重地";
System.out.println(str1.hashCode());
System.out.println(str2.hashCode());
System.out.println(str3.hashCode());
System.out.println(str4.hashCode());
HashSet<String> hashSet = new HashSet<>();
hashSet.add(str1);
hashSet.add(str2);
hashSet.add(str4);
hashSet.add(str3);
System.out.println(hashSet);
}
}

23
s_day03/src/com/inmind/set_02/Demo05.java Normal file
View File

@@ -0,0 +1,23 @@
package com.inmind.set_02;
import java.util.HashSet;
/*
13.HashSet存储自定义对象
注意：我们保存数据时，先判断哈希值，如果不一样直接存，如果哈希值相同，还要使用equals方法判断内容
是否相同，如果相同，就不存，不同则保存，所以必须重写hashCode和equals
*/
public class Demo05 {
public static void main(String[] args) {
Persion p1 = new Persion("刘备", 20);
Persion p4 = new Persion("刘备", 20);
Persion p3 = new Persion("张飞", 20);
Persion p2 = new Persion("关羽", 20);
HashSet<Persion> sets = new HashSet<>();
sets.add(p1);
sets.add(p2);
sets.add(p3);
sets.add(p4);
System.out.println(sets);
}
}

36
s_day03/src/com/inmind/set_02/Demo06.java Normal file
View File

@@ -0,0 +1,36 @@
package com.inmind.set_02;
import java.util.HashSet;
import java.util.LinkedHashSet;
/*
LinkedHashSet的特点
1.存取有序
2.没有索引
3.不能重复
LinkedHashSet的底层数据结构：在哈希表的基础上，添加了链表
哈希表：去重，高效查询
链接：保证数据的顺序
注意：当我们定义的集合既要去重，也要保证顺序，采用LinkedHashSet
*/
public class Demo06 {
public static void main(String[] args) {
HashSet<String> sets = new HashSet<>();
sets.add("刘备");
sets.add("关羽");
sets.add("张飞");
System.out.println(sets);
System.out.println("------------------------------------");
LinkedHashSet<String> linkedSets = new LinkedHashSet<>();
linkedSets.add("张飞");
linkedSets.add("关羽");
linkedSets.add("关羽");
linkedSets.add("关羽");
linkedSets.add("刘备");
linkedSets.add("刘备");
linkedSets.add("刘备");
System.out.println(linkedSets);
}
}

33
s_day03/src/com/inmind/set_02/Persion.java Normal file
View File

@@ -0,0 +1,33 @@
package com.inmind.set_02;
import java.util.Objects;
public class Persion {
String name;
int age;
public Persion(String name, int age) {
this.name = name;
this.age = age;
}
@Override
public boolean equals(Object o) {
if (o == null || getClass() != o.getClass()) return false;
Persion persion = (Persion) o;
return age == persion.age && Objects.equals(name, persion.name);
}
@Override
public int hashCode() {
return Objects.hash(name, age);
}
@Override
public String toString() {
return "Persion{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
}

26
s_day03/src/com/inmind/set_02/Student.java Normal file
View File

@@ -0,0 +1,26 @@
package com.inmind.set_02;
import java.util.Objects;
public class Student {
String name;
int age;
public Student(String name, int age) {
this.name = name;
this.age = age;
}
@Override
public boolean equals(Object o) {
if (!(o instanceof Student)) return false;
Student student = (Student) o;
return age == student.age && Objects.equals(name, student.name);
}
@Override
public int hashCode() {
return Objects.hash(name, age);
}
}

17
s_day03/src/com/inmind/test05/Poker.java Normal file
View File

@@ -0,0 +1,17 @@
package com.inmind.test05;
//自定义的方式，实现牌的排序
public class Poker implements Comparable<Poker> {
String content;
int sort;
public Poker(String content, int sort) {
this.content = content;
this.sort = sort;
}
@Override
public int compareTo(Poker o) {
return this.sort - o.sort;
}
}

79
s_day03/src/com/inmind/test05/Test.java Normal file
View File

@@ -0,0 +1,79 @@
package com.inmind.test05;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.HashMap;
/*
按照斗地主的规则，完成洗牌发牌的动作。
具体规则：
使用54张牌打乱顺序,三个玩家参与游戏，三人交替摸牌，每人17张牌，最后三张留作底牌。
步骤分析：
1.准备54张牌（花色+数字）
2.洗牌（打乱牌的顺序)
3.创建3个集合轮流摸牌，创建1个集合保存底牌
4.打印集合的内容
*/
public class Test {
public static void main(String[] args) {
//1.准备54张牌（花色+数字）
String [] colors = {"♠", "♥", "♣", "♦"};
String[] nums = {"3", "4", "5", "6", "7", "8", "9", "10", "J", "Q", "K", "A", "2"};
ArrayList<String> pokers = new ArrayList<>();
for (String color : colors) {
for (String num : nums) {
String poker = color+num;
pokers.add(poker);
}
}
pokers.add("大王");
pokers.add("小王");
System.out.println(pokers.size());
System.out.println(pokers);
//2.洗牌（打乱牌的顺序)
System.out.println("洗牌之后：");
Collections.shuffle(pokers);
System.out.println(pokers);
//3.创建3个集合轮流摸牌，创建1个集合保存底牌
ArrayList<String> player1 = new ArrayList<>();
ArrayList<String> player2 = new ArrayList<>();
ArrayList<String> player3 = new ArrayList<>();
ArrayList<String> dipai = new ArrayList<>();
/*
玩家1 0 3 6 %3 = 0
玩家2 1 4 7 %3 = 1
玩家3 2 5 8 %3 = 2
*/
for (int i = 0; i < pokers.size(); i++) {
if (i >= pokers.size() - 3) {
dipai.add(pokers.get(i));
}else{
switch (i%3) {
case 0:
player1.add(pokers.get(i));
break;
case 1:
player2.add(pokers.get(i));
break;
case 2:
player3.add(pokers.get(i));
break;
}
}
}
//4.打印集合的内容（预留：如何实现抓完牌之后的排序功能升序，降序）
System.out.println("抓牌之后：");
System.out.println(player1);
System.out.println(player2);
System.out.println(player3);
System.out.println(dipai);
HashMap<Object, Object> map = new HashMap<>();
}
}

183
s_day03/src/com/inmind/test06/CartSytem.java Normal file
View File

@@ -0,0 +1,183 @@
package com.inmind.test06;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Map;
import java.util.Scanner;
public class CartSytem {
//保存所有的商品list
private static ArrayList<Product> products = new ArrayList<>();
//保存购物车map
private static HashMap<Product,Integer> carts = new HashMap<>();
private static Scanner sc = new Scanner(System.in);
public static void main(String[] args) {
//初始化商品
initData();
//提示
System.out.println("===== 简易购物系统 =====");
showMainMenu();
}
private static void showMainMenu() {
while (true) {
boolean flag = false;
System.out.println();
System.out.println();
System.out.println("===== 主菜单 =====");
System.out.println("1. 浏览所有商品");
System.out.println("2. 搜索商品");
System.out.println("3. 查看购物车");
System.out.println("4. 添加商品到购物车");
System.out.println("5. 修改购物车商品数量");
System.out.println("6. 清空购物车");
System.out.println("7. 退出");
System.out.println("8. 按分类去查看商品？？？");
System.out.println("请选择:");
int choice = sc.nextInt();
if (choice<1||choice>7) {
System.out.println("无效的选项");
continue;
}
switch (choice) {
case 1: browsProducts(); break;
case 2: searchProduct(); break;
case 3: showCarts(); break;
case 4: addCart(); break;
case 5: putCart(); break;
case 6: clearCart(); break;
case 7:
System.out.println("谢谢使用！！再见");
flag = true;
break;
}
if (flag) {
break;//结束外面的死循环
}
}
}
private static void clearCart() {
carts.clear();
System.out.println("购物车已清空");
}
private static void putCart() {
System.out.println("请输入要修改的商品ID:");
sc.nextLine();
String pId = sc.nextLine();
//先判断下是否有该商品
Product product = null;
for (Product p : carts.keySet()) {
if (p.getId().equals(pId)) {
product = p;
}
}
//如果有则保存数量，如没有则return
if (product == null) {
System.out.println("购物车中未找到该商品");
return;
}
System.out.println("请输入新的数量:");
int quantity = sc.nextInt();
carts.put(product,quantity);
System.out.println("数量已更新");
}
private static void addCart() {
System.out.println("请输入商品ID: ");
sc.nextLine();
String pId = sc.nextLine();
//先判断下是否有该商品
Product product = null;
for (Product p : products) {
if (p.getId().equals(pId)) {
product = p;
}
}
//如果有则保存数量，如没有则return
if (product == null) {
System.out.println("未找到该商品");
return;
}
System.out.println("请输入购买数量:");
int quantity = sc.nextInt();
//添加到购物车，product：数量
if (carts.containsKey(product)) {
carts.put(product, carts.get(product) + quantity);
} else {
carts.put(product, quantity);
}
System.out.println("已加入购物车");
}
private static void showCarts() {
System.out.println("===== 购物车 =====");
if (carts.isEmpty()) {
System.out.println("购物车是空的！！");
return;
}
int total = 0;//总价
for (Map.Entry<Product, Integer> entry : carts.entrySet()) {
Product product = entry.getKey();
Integer count = entry.getValue();
int sum = product.getPrice()*count;
System.out.println(product.getName()+", 数量: "+count+", 小计: ￥"+sum);
total += sum;
}
System.out.println("购物车总计: ￥"+total);
}
private static void searchProduct() {
System.out.println("请输入商品名称关键字:");
sc.nextLine();
String search = sc.nextLine();
ArrayList<Product> searchLists = new ArrayList<>();
for (Product product : products) {
if (product.getName().contains(search)) {
searchLists.add(product);
}
}
System.out.println("===== 搜索结果 =====");
if (searchLists.size() == 0) {
System.out.println("没有找到匹配的商品");
} else {
for (Product product : searchLists) {
System.out.println(product);
}
}
}
private static void browsProducts() {
System.out.println("===== 所有商品 =====");
for (Product product : products) {
System.out.println(product);
}
System.out.println();
}
private static void method() {
}
private static void initData() {
products.add(new Product("P01", "笔记本电脑", 5999, "电子产品", 10));
products.add(new Product("P02", "机械键盘", 299, "电脑配件", 20));
products.add(new Product("P03", "无线鼠标", 129, "电脑配件", 30));
products.add(new Product("P04", "蓝牙耳机", 799, "音频设备", 15));
products.add(new Product("P05", "智能手机", 3999, "电子产品", 25));
}
}

83
s_day03/src/com/inmind/test06/Product.java Normal file
View File

@@ -0,0 +1,83 @@
package com.inmind.test06;
import java.util.Objects;
public class Product {
//商品编号
private String id;
//名称
private String name;
//价格
private Integer price;
//分类
private String category;
//数量
private Integer quantity;
public Product(String id, String name, Integer price, String category, Integer quantity) {
this.id = id;
this.name = name;
this.price = price;
this.category = category;
this.quantity = quantity;
}
public String getId() {
return id;
}
public void setId(String id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Integer getPrice() {
return price;
}
public void setPrice(Integer price) {
this.price = price;
}
public String getCategory() {
return category;
}
public void setCategory(String category) {
this.category = category;
}
public Integer getQuantity() {
return quantity;
}
public void setQuantity(Integer quantity) {
this.quantity = quantity;
}
@Override
public String toString() {
return "ID: "+this.id+", 名称: "+this.name+", 价格: ￥"+this.price+", 分类: "+this.category+", 库存: "+this.quantity;
}
@Override
public boolean equals(Object o) {
if (!(o instanceof Product)) return false;
Product product = (Product) o;
return Objects.equals(id, product.id);
}
@Override
public int hashCode() {
return Objects.hashCode(id);
}
}

45
s_day03/src/com/inmind/var_params_03/Demo01.java Normal file
View File

@@ -0,0 +1,45 @@
package com.inmind.var_params_03;
/*
在jdk5中，提供可变参数，当我们要定义多个同一种类型的参数，并且，个数还不确定时，此时可以用可变参数来替代
可变参数的语法：
(数据类型... 参数名)
可变参数也是一个语法糖，本质不变，就是数组
注意事项：
1.可变参数在一个参数列表中只能出现一次
2.如果有多个参数，可变参数必须在最后一个
*/
public class Demo01 {
public static void main(String[] args) {
//计算2个整数
System.out.println(getSum("1",1, 2));
//计算5个整数
System.out.println(getSum("1",1, 2,3,4,5));
//计算7个整数
System.out.println(getSum("1",1, 2,3,4,5,6,7));
}
public static int getSum(String str3,int...arr){
int sum = 0;
for (int i : arr) {
sum += i;
}
return sum;
}
/*//定义2个整数相加之和的方法
public int getSum(int a, int b) {
return a + b;
}
//定义3个整数相加之和的方法
public int getSum(int a, int b, int c) {
return a + b + c;
}
//定义4个整数相加之和的方法
public int getSum(int a, int b, int c, int d) {
return a + b + c + d;
}*/
}