一:数据结构:
(1) 栈:
特点:先进后出;
进栈的方式:压栈;
出栈的方式:弹栈;
(2) 队列:
特点:先进先出
(3) 数据机构是数组:查询快,增删慢
(4) 数据结构是链表:查询慢,增删快
二,泛型
(1) 泛型:把数据类型的明确工作提供提前到了创建对象或者是调用方法的时期明确的一种特殊类型.参数化类型,可以像参数一样进行传递
格式: <引用类型>:泛型只能放引用类型
(2) 泛型好处:
1,将运行时期异常提前到了编译时期
2解决了黄色警告线问题
3获取数据的时候,不用强制类型转换了
(3) 泛型的应用: 一般情况:泛型可以应用在接口,类,或者方法上;主要用在集合中比较多!
#泛型大的简单应用:
packageGenericDemo_01;
importjava.util.ArrayList;
importjava.util.Iterator;
public class GenericText_01 {
public static void main(String[] args) {
ArrayList<String> Str=new ArrayList<String>();//创建ArrayList对象,
Str.add("这 ");
Str.add("是 ");
Str.add("一 ");
Str.add("个 ");
Str.add("字 ");
Str.add("符 ");
Str.add("串!");
Iterator<String> it=Str.iterator();
for(String s:Str){//增强for循环,遍历该集合
System.out.print(s);
}
}
}
#泛型为一个具体类:
packageGenericDemo_01;
importjava.util.ArrayList;
public class GenericText_02 {
public static void main(String[] args) {
ArrayList<Student> al=new ArrayList<Student>();//泛型为一个具体类
Student s1=new Student(22,"王抢");//创建学生类的有参构造,并初始化成员变量
Student s2=new Student(23,"上官万成");
Student s3=new Student(30,"欧阳");
al.add(s1);//调用ArrayList集合的Add()方法.给集合添加元素
al.add(s2);
al.add(s3);
for(Student s:al){
System.out.println(s.getName() + "--" + s.getAge());
}
}
}
class Student{
private int age;
private String name;
public Student() {
super();
// TODO自动生成的构造函数存根
}
public Student(int age, String name) {
super();
this.age = age;
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
#泛型修饰方法与修饰类:
packageGenericDemo_02;
public class GenericText_01 {
public static void main(String[] args) {
GenericDemo01<String>gd1=new GenericDemo01<String>();
gd1.show("这是调用泛型修饰String类型的方法");
GenericDemo01<Integer> gd2=new GenericDemo01<Integer>();
gd2.show(120);//调用泛型修饰integer类型的方法
GenericDemo01<Boolean> gd3=new GenericDemo01<Boolean>();
gd3.show(true);//调用Boolean修饰的方法
GenericDemo02 gd=new GenericDemo02();
gd.show("可以是String类型");
gd.show(120);//也可以是int类型
gd.show(false);//也可以是Boolean类型
}
}
classGenericDemo01<T>{//泛型修饰类
public static void show(String s){
System.out.println("字符串为:" + s);
}
public static void show(Integer i){
System.out.println("Integer类型的数为:" + i);
}
public static void show(Boolean flag){
System.out.println("布尔类型的值为:" + flag);
}
}
class GenericDemo02{
public <T> void show(T t){//泛型修饰方法
System.out.println("泛型修饰方法结果为:" + t);
}
}
(4) 泛型定义在接口上:
第一种情况:接口的子实现类已经知道传递的是什么数据类型
例: public class InterImpl<String>implements Inter<String>
#泛型修饰接口,且该接口的子实现类已经传递了String类型:
packageGenericDemo_03;
//测试类
public class GenerictText_01 {
public static void main(String[] args) {
intefer<String> i=new Interface<String>();
i.show();
}
}
packageGenericDemo_03;
//接口类
public interface intefer<String> {
public abstract void show();
}
packageGenericDemo_03;
//接口的子实现类
public class Interface<String> implements intefer<String> {
@Override
public void show() {
System.out.println("该接口的泛型为String类型,接口的子实现类已经传递了String类型");
// TODO自动生成的方法存根
}
}
第二种情况:接口的子实现类在实现接口的时候,不知道具体的数据类型是什么, 在测试类的时候,传入具体数据类型
例: public class InterImpl<T> implementsInter<T>
#泛型修饰接口,切不知道传入的参数的类型,需要在测试时传入数据类型:
packageGenericDemo_04;
//测试类
public class GenericText_01 {
public static void main(String[] args) {
Intefer<String> i=new InteferDemo<String>();
i.show("you are my sunshine!");
}
}
packageGenericDemo_04;
//接口类
public interface Intefer<T>{
public abstract void show(T t);
}
packageGenericDemo_04;
//接口的子实现类
public class InteferDemo<T> implements Intefer<T> {
@Override
public void show(T t) {
System.out.println("这是泛型修饰接口时,不知道传入的参数类型,需要在测试时,参入参数的类型" + t);
// TODO自动生成的方法存根
}
}
(5) 泛型的高级:通配符
<?> :可以是任意类型,包括Object类型以及任意的Java类
<? extends E>:向下限定,E类型以及E类型的子类
<? super E>:向上限定,E类型以及E类型的父类
#泛型的高级综合应用:
packageGenericDemo_05;
importjava.util.ArrayList;
importjava.util.Collection;
public class GenericText_01 {
public static void main(String[] args) {
Collection<?> Cl1=new ArrayList<Object>();//<?> :可以是任意类型,包括Object类型以及任意的Java类
Collection<? extends animal> Cl2=new ArrayList<dog>();//<? extends E>:向下限定,E类型以及E类型的子类
Collection<? super dog> Cl3=new ArrayList<animal>();//<? super E>:向上限定,E类型以及E类型的父类
}
}
class animal{
}
class dog extends animal{
}
三: 增强for循环
(1) 书写格式:
for(集合或者数组中的数据类型 变量名:集合或者数组的对象名){
输出变量名;
}
(2)增强for循环的弊端:
遍历数组或者集合的时候,数组对象或者集合对象不能为null,如果对象为空,一般加上非空判断; (如果为空: java.lang.NullPointerException:空指针异常)
增强for循环的出现就是为了替代迭代器遍历集合的,以后开发中就是用增强for遍历元素
(3)使用ArrayList集合存储自定义对象并遍历
1)toArray()
2)Collection集合的迭代器:Iterator iterator();
3)List集合的迭代器:ListIterator listiterator();
4)普通for循环:size()和get(int index)相结合
5)增强for循环
#遍历集合的综合应用:
packageGenericDemo_06;
importjava.util.ArrayList;
importjava.util.Iterator;
public class BianLi {
public static void main(String[] args) {
ArrayList<Student> al=new ArrayList<Student>();//创建ArrayList集合
Student s1=new Student(23,"王抢");
Student s2=new Student(25,"上官完成");
al.add(s1);
al.add(s2);
System.out.println("使用for循环和size()方法和get()方法遍历集合");
for(int i=0;i<al.size();i++){
System.out.println(al.get(i));
}
System.out.println("使用toArray()方法遍历集合:");
Object []obj=al.toArray();
for(int i=0;i<obj.length;i++){
Student s=(Student)obj[i];
System.out.println(s.getName() + "--" + s.getAge());
}
System.out.println("使用迭代器遍历集合:");
Iterator<Student>it=al.iterator();
while(it.hasNext()){
System.out.println(it.next().getName() + "--" +it.next().getAge());
}
System.out.println("使用增强for()循环遍历集合:");
for(Student s:al){
System.out.println(s.getName() + "--" + s.getAge());
}
}
}
class Student{
private int age;
private String name;
public Student() {
super();
// TODO自动生成的构造函数存根
}
public Student(int age, String name) {
this.age = age;
this.name = name;
}
public int getAge() {
return age;
}
public String getName() {
return name;
}
public void setAge(int age) {
this.age = age;
}
public void setName(String name) {
this.name = name;
}
@Override
public String toString() {
return "Student [age=" + age + ",name=" + name + "]";
}
}
#集合的嵌套遍历:
packageGenericDemo_07;
importjava.util.ArrayList;
public class ArrayListQianTao {
public static void main(String[] args) {
ArrayList<ArrayList<Student>>bigAl=newArrayList<ArrayList<Student>>();//创建年级集合
ArrayList<Student> class1=new ArrayList<Student>();//创建班级一的集合
Student s1=new Student(22,"孙漂亮");
Student s2=new Student(23,"朱碧石");
class1.add(s1);
class1.add(s2);
bigAl.add(class1);//将班级一封装在年级集合中
ArrayList<Student> class2=new ArrayList<Student>();//创建二班集合
Student ss1=new Student(24,"唐僧");
Student ss2=new Student(25,"八戒");
class2.add(ss1);
class2.add(ss2);
bigAl.add(class2);//将班级二封装在年级集合中
for(ArrayList<Student> Arr:bigAl){
for(Student s:Arr){
System.out.println(s.getName() + "--" + s.getAge());
}
}
}
}
class Student{
private int age;
private String name;
public Student() {
super();
// TODO自动生成的构造函数存根
}
public Student(int age, String name) {
super();
this.age = age;
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
四: List集合的子实现类的特点:
ArrayList: 底层数据结构是数组的形式,满足数组结构的特点:查询快,增删慢从线程安全问题来看:线程不安全的,不同步,执行效率高
Vector: 底层数据结构是数组的形式,查询快,增删慢从线程角度看:线程安全的类,同步,执行效率低
LinkedList: 底层数据结构是链接列表,特点:查询慢,增删快从线程角度看:线程不安全的一个类,不同步,执行效率高
#如果实现多线程程序,一般要是安全的类: StringBuffer,Vector<E>,hashtable<K,V>
synchronized(同步锁对象){
代码;
}
#如果在一般的需求中没有指明使用集合去完成,都默认采用ArrayList; 如果需求中要考虑线程安全,那么使用Vector集合!
#使用ArrayList集合遍历自定义对象元素: ,它元素可以重复,并且存储和取出一致
packageArrayListDemo_01;
importjava.util.ArrayList;
importjava.util.Iterator;
public class ArrayListText_01 {
public static void main(String[] args) {
ArrayList al=new ArrayList();//创建ArrayList集合,并遍历自定义对象
Student s1=new Student(23,"上官万成");
Student s2=new Student(22,"王抢");
Student s3=new Student(24,"朱碧石");
al.add(s1);
al.add(s2);
al.add(s3);
Iteratorit=al.iterator();//创建迭代器对象
System.out.println("以下是使用ArrayList集合遍历自定义对象元素:");
while(it.hasNext()){
Student s=(Student)it.next();
System.out.println(s.getName() + "---" + s.getAge());
}
}
}
class Student{
private int age;
private String name;
public Student() {
super();
// TODO自动生成的构造函数存根
}
public Student(int age, String name) {
super();
this.age = age;
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
#使用Vector集合遍历自定义对象的元素:
packageVectorDemo_01;
importjava.util.Enumeration;
importjava.util.Vector;
public class VectorText_01 {
public static void main(String[] args) {
Vector vt=new Vector();//创建Vector集合
Student s1=new Student(23,"唐僧");
Student s2=new Student(26,"孙悟空");
Student s3=new Student(24,"八戒");
vt.addElement(s1);//向集合中添加元素
vt.addElement(s2);
vt.addElement(s3);
Enumeration en=vt.elements();//创建Enumeration对象,该对象类似于接口Iterator对象
System.out.println("以下是使用Vector集合遍历自定义对象的元素");
while(en.hasMoreElements()){//判断是否有下一个可以遍历的元素
Student s=(Student)en.nextElement();
System.out.println(s.getName() + "---" + s.getAge());
}
}
}
class Student{
private int age;
private String name;
public Student() {
super();
// TODO自动生成的构造函数存根
}
public Student(int age, String name) {
super();
this.age = age;
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
(2)LinkedList:
添加功能:
public void addFirst(E e)将指定元素插入此列表的开头。
public void addLast(E e)将指定元素添加到此列表的结尾。
获取功能:
public Object getFirst()返回此列表的第一个元素
public Object getLast()返回此列表的最后一个元素。
删除功能:
public Object removeFirst()移除并返回此列表的第一个元素。
public Object removeLast()移除并返回此列表的最后一个元素。
#LinkedList集合综合应用:
packageLinkedListText_01;
importjava.util.LinkedList;
public class LinkedListText01 {
public static void main(String[] args) {
LinkedList ll=new LinkedList();//创建LinkedList集合
ll.addFirst("life!");
ll.addFirst("my ");
ll.addFirst("are ");
ll.addFirst("you ");//向该集合中添加第一个元素
ll.addLast("last!");//向该集合中添加最后一个元素
Object obj1=ll.getFirst();//获取该集合中的第一个元素
Object obj2=ll.getLast();//获取该集合中的最后一个元素
System.out.println("第一个元素是:" + obj1);
System.out.println("最后一个元素是:" + obj2);
Object obj3=ll.removeFirst();//移除该集合中的第一个元素
Object obj4=ll.removeLast();//移除该集合中的最后一个元素
System.out.println("移除第一个元素:" + obj3);
System.out.println("移除最后一个元素:" + obj4);
}
}
#使用ArrayList集合的contains()方法去除集合中的重复元素:
packageArrayListDemo_02;
importjava.util.ArrayList;
importjava.util.Iterator;
public class ArrayList_01 {
public static void main(String[] args) {
ArrayList al1=new ArrayList();
al1.add("you");
al1.add("are");
al1.add("my");
al1.add("life!");
al1.add("you");//向集合中添加重复元素
ArrayList al2=new ArrayList();
Iterator it=al1.iterator();
while(it.hasNext()){
String s=(String)it.next();//获取集合中的每一个元素
if(!al2.contains(s)){
al2.add(s);
System.out.print(s + " ");
}
}
}
}
#使用ArrayList集合中的size()方法和get()方法去除集合中的重复元素:
packageArrayListDemo_02;
importjava.util.ArrayList;
importjava.util.Iterator;
public class ArrayList_01 {
public static void main(String[] args) {
ArrayList al1=new ArrayList();
al1.add("you");
al1.add("are");
al1.add("my");
al1.add("life!");
al1.add("you");//向集合中添加重复元素
for(int i=0;i<al1.size()-1;i++){
for(int j=i+1;j<al1.size();j++){
if(al1.get(i).equals(al1.get(j))){
al1.remove(j);
j--;
}
}
}
Iterator it=al1.iterator();
while(it.hasNext()){
String s=(String)it.next();
System.out.print(s + " ");
}
}
}
#使用LinkedList模拟一个栈结构的特点
packageLinkedListText_01;
importjava.util.LinkedList;
public class LinkedListText_03 {
public static void main(String[] args) {
MyStack ms=new MyStack() ;
ms.add("you ");//向集合中添加元素
ms.add("are ");
ms.add("my ");
ms.add("sunshine!");
System.out.println(ms.get());
System.out.println(ms.get());
System.out.println(ms.get());
while(!ms.isEmpty()){//判空操作,如果不为空,继续返回被删除的元素
System.out.println(ms.get());
}
}
}
class MyStack{
private LinkedList link;
public MyStack() {
link = new LinkedList() ;
// TODO自动生成的构造函数存根
}
public MyStack(LinkedList link) {
this.link = link;
}
public void add(Object obj){//向集合添加元素
link.addFirst(obj) ;
}
public Object get(){//获取集合中的元素
return link.removeFirst() ;//该方法返回被删除的元素
}
public boolean isEmpty(){
return link.isEmpty() ;//判断集合是否为空
}
}
五, Set集合
(1) Set接口: Set集合继承自Collection集合; 底层数据结构是一个哈希表,能保证元素是唯一的,元素不重复! 它通过它的子实现了HashSet集合去实例化,HashSet集合底层是HashMap集合的实例!
#Set集合遍历集合元素:
packageSet_01;
importjava.util.HashSet;
importjava.util.Set;
public class SetText_01 {
public static void main(String[] args) {
Set<String> st=new HashSet<String>();//创建Set的子实现类hashSet对象
st.add("we");//向集合添加元素
st.add("are");
st.add("the");
st.add("are");
st.add("fight!");
for(String s:st){
System.out.println(s);
}
}
}
(2) List集合和Set集合的区别:
Set:元素是唯一的,无序性(存储和取出不一致)
List:元素可以重复,有序性(存储和取出一致)
(3) HashSet集合的add()方法:
如何保证集合元素的唯一性:
HashSet集合的add()方法,底层是依赖于双列集合HashMap<K,V>的put(K key,V value)来实现的,而put(K key,V value)底层又依赖于HashCode()和equals()方法,传递添加元素的时候,首先判断的是 每一个元素对应的HashCode值是否一样,如果HashCode值一样,还比较他们的equals()方法,如果地址和内容都相同,这里最终返回的就是第一次存储的那个元素,由这两个方法保证元素唯一性!
#使用HashSet集合遍历自定义对象元素:
package SetDemo01;
import java.util.HashSet;
import java.util.Set;
public class SetText_01 {
public static void main(String[] args) {
HashSet<Student> st=new HashSet<Student>();//创建Set的子实现类对象
Student s1=new Student(23,"唐僧");
Student s2=new Student(26,"八戒");
Student s3=new Student(26,"八戒");//为集合添加重复元素,
Student s4=new Student(27,"八戒");
st.add(s1);
st.add(s2);
st.add(s3);//HashSet集合的add()方法,底层是依赖于双列集合HashMap<K,V>的put(Kkey,V value)来实现的,而put(Kkey,V value)底层又依赖于HashCode()和equals()方法,传递添加元素的时候,首先判断的是每一个元素对应的HashCode值是否一样,如果HashCode值一样,还比较他们的equals()方法,如果地址和内容都相同,这里最终返回的就是第一次存储的那个元素,由这两个方法保证元素唯一性!
st.add(s4);
for(Student s:st){
System.out.println(s.getName() + "---" + s.getAge());
}
}
}
class Student{
private int age;
private String name;
public Student() {
super();
// TODO Auto-generatedconstructor stub
}
public Student(int age, String name) {
super();
this.age = age;
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
@Override
public int hashCode() {
final int prime = 31;
int result = 1;
result = prime * result + age;
result = prime * result + ((name == null) ? 0 : name.hashCode());
return result;
}
@Override
public boolean equals(Object obj) {
if (this == obj)
return true;
if (obj == null)
return false;
if (getClass() != obj.getClass())
return false;
Student other = (Student) obj;
if (age != other.age)
return false;
if (name == null) {
if (other.name != null)
return false;
} else if (!name.equals(other.name))
return false;
return true;
}
}
(4) LinkedHashSet集合:
由哈希表保证元素的唯一性; 由链接列表来保证元素的有序性!
#LinkedHashSet集合遍历集合元素:
package SetDemo01;
import java.util.LinkedHashSet;
public class LinkedHashSet_Text01 {
public static void main(String[] args) {
LinkedHashSet<String> ls=new LinkedHashSet<String>();//创建LinkedHashSet对象,该集合由HashSet集合保证元素的唯一性,由LinkedList集合保证元素的有序性
ls.add("This ");
ls.add("is ");
ls.add("my ");
ls.add("life!");
for(String s:ls){
System.out.print(s);
}
}
}
六,TreeSet集合:
(1) TreeSet集合底层是依赖于TreeMap的实例,而TreeMap<K,V>是依赖于红黑树结构实现的
#自然排序:
package TreeSetText_o1;
import java.util.TreeSet;
public class TreeSet_01 {
public static void main(String[] args) {
TreeSet<Integer> ts=new TreeSet<Integer>();
ts.add(13);
ts.add(23);
ts.add(9);
ts.add(11);
ts.add(17);
ts.add(21);
for(Integer i:ts){
System.out.print(i + " ");
}
}
}
(2) 对于TreeSet集合存储自定义对象必须实现一个接口:compareable接口
#使用TreeSet集合自然排序自定义对象元素:
package TreeSetText_o1;
import java.util.TreeSet;
public class TreeSet_o2 {
public static void main(String[] args) {
TreeSet<Student> ts=new TreeSet<Student>();//创建TreeSet集合对象
Student s1=new Student(22,"shangguanwangcehng");
Student s2=new Student(23,"ouyangchengfeng");
Student s3=new Student(24,"wangshabi");
Student s4=new Student(24,"wangqiang");
ts.add(s1);
ts.add(s2);
ts.add(s3);
ts.add(s4);
for(Student s:ts){
System.out.println(s.getName() + "---" + s.getAge() + "岁");
}
}
}
class Student implements Comparable<Student>{
private int age;
private String name;
public Student(int age, String name) {
super();
this.age = age;
this.name = name;
}
public Student() {
super();
// TODO Auto-generatedconstructor stub
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
@Override
public int compareTo(Student s) {
// TODO Auto-generatedmethod stub
int num1=this.age-s.age;//按年龄从小到大排序
int num2=num1==0?this.name.compareTo(s.name):num1;//在根据名字内容排序
return num2;
}
}
#结论:对于TreeSet集合要实现自然排序,那么该集合中存储自定义类型必须实现一个接
口:Comparable,并且重写该接口中的compareTo()方法使用TreeSet集合存储自定义对象并遍历
(3) 使用TreeSet集合遍历集合元素,按照姓名长度的大小排序:
TreeSet集合使用比较器进行给元素进行排序;
#方法一:自定义一个类,实现接口Comparator
package TreeSetText_o1;
import java.util.Comparator;
import java.util.TreeSet;
public class TreeSet_text03 {
public static void main(String[] args) {
TreeSet<Student1> ts=new TreeSet<Student1>(new MyComparator());//使用TreeSet集合的比较器排序,需要调用TreeSet集合的有参构造,public TreeSet(Comparator<E> comparator)
Student1 s1=new Student1(23,"sgangguanwancheng");
Student1 s2=new Student1(24,"ouyangchangfen");
Student1 s3=new Student1(22,"hunagpu");
Student1 s4=new Student1(16,"wangqiang");
ts.add(s1);
ts.add(s2);
ts.add(s3);
ts.add(s4);
System.out.println("以下是将每个人的信息根据姓名的长度大小排序:");
for(Student1 s:ts){
System.out.println(s.getName() + "---" + s.getAge());
}
}
}
class Student1{
private int age;
private String name;
public Student1() {
super();
// TODO Auto-generatedconstructor stub
}
public Student1(int age, String name) {
super();
this.age = age;
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
class MyComparator implements Comparator<Student1>{//MyComparatpr是接口Comparator的子实现类
@Override
public int compare(Student1 s11, Student1 s12) {
// TODO Auto-generatedmethod stub
int num1=s12.getName().length()-s11.getName().length();//根据姓名的长度,从大到小排序
return num1;
}
}
#方法二: 可以使用接口的匿名内部类来实现:开发中,由于减少代码书写量,不需要自定义接口的子实现类,直接这种格式!
package TreeSetText_o1;
import java.util.TreeSet;
import java.util.Comparator;
public class TreeSet_text04 {
public static void main(String[] args) {
TreeSet<Student2> ts=new TreeSet<Student2>(newComparator<Student2>(){//创建接口的匿名内部类形式,可以省略代码
@Override
public int compare(Student2 s11, Student2 s12) {
// TODO Auto-generated method stub
int num1=s12.getName().length()-s11.getName().length();//主要条件,根据姓名的长度,从大到小排序
int num2=num1==0?s11.getAge()-s12.getAge():num1;//次要条件,如果姓名长度相等,则按照年龄从小到大排列
return num2;
}
});
System.out.println("以下是采用TreeSet集合的比较器进行遍历集合对象");
Student2 s1=new Student2(22,"shangguanwancheng");
Student2 s2=new Student2(21,"ouyangchengfeng");
Student2 s3=new Student2(20,"huangpu");
Student2 s4=new Student2(23,"wangqiang");
Student2 s5=new Student2(21,"wangqiang");
Student2 s6=new Student2(20,"wangqiang");
ts.add(s1);
ts.add(s2);
ts.add(s3);
ts.add(s4);
ts.add(s5);
ts.add(s6);
for(Student2 s:ts){
System.out.println(s.getName() + "---" + s.getAge());
}
}
}
class Student2{
private int age;
private String name;
public Student2() {
super();
// TODO Auto-generatedconstructor stub
}
public Student2(int age, String name) {
super();
this.age = age;
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
#键盘录入五位学生的语文,数学,英语成绩,按总分降序排列,如果总分相同,按语文成绩降序排列,如果语文成绩相同时,按英语成绩降序排列:
package TreeSetText_o1;
import java.util.Scanner;
import java.util.TreeSet;
import java.util.Comparator;
public class TreeSet_text05 {
publicstatic void main(String[] args) {
TreeSet<Student3>ts=new TreeSet<Student3>(new Comparator<Student3>(){
@Override
publicint compare(Student3 s11, Student3 s12) {
//TODO Auto-generated method stub
intnum1=s12.SumAll()-s11.SumAll();//主要条件,按总成绩从高到低排序
intnum2=num1==0?s12.getChinese()-s11.getChinese():num1;//党总成绩相同时,将语文成绩按从大到小排列
intnum3=num2==0?s12.getEnglish()-s11.getEnglish():num2;//当语文成绩也相同时,按英语成绩从大到小排列
returnnum3;
}
});
System.out.println("从键盘录入五个学生的成绩信息:");
Scannersc=new Scanner(System.in);
for(inti=1;i<=5;i++){
System.out.println("请输入第 " + i +" 个学生的姓名:");
Stringname=sc.nextLine();
System.out.println("请输入第" + i + "个学生的语文成绩:");
StringChineseCourse=sc.nextLine();
System.out.println("请输入第" + i + "个学生的数学成绩:");
StringmathCourse=sc.nextLine();
System.out.println("请输入第" + i + "个学生的英语成绩:");
StringEnglishCourse=sc.nextLine();
//创建学生对象,将学生信息封装在学生对象中
Student3st=new Student3();
st.setName(name);
st.setChinese(Integer.parseInt(ChineseCourse));
st.setEnglish(Integer.parseInt(mathCourse));
st.setEnglish(Integer.parseInt(EnglishCourse));
ts.add(st);//将学生对象的信息封装在TreeSet集合中
}
System.out.println("学生信息录入结束:");
System.out.println("学生信息总分从高到底排列数学如下:");
System.out.println("姓名\t语文成绩\t数学成绩\t英语成绩");
for(Student3s:ts){
System.out.println(s.getName()+ "\t" + s.getChinese() + "\t" + s.getEnglish() + "\t"+ s.getMath());
}
}
}
class Student3{
privateString name;
private int English;
private int Chinese;
private int Math;
publicStudent3() {
super();
//TODO Auto-generated constructor stub
}
publicStudent3(String name, int english, int chinese, int math) {
super();
this.name= name;
English= english;
Chinese= chinese;
Math= math;
}
publicString getName() {
returnname;
}
publicvoid setName(String name) {
this.name= name;
}
publicint getEnglish() {
returnEnglish;
}
publicvoid setEnglish(int english) {
English= english;
}
publicint getChinese() {
returnChinese;
}
publicvoid setChinese(int chinese) {
Chinese= chinese;
}
publicint getMath() {
returnMath;
}
publicvoid setMath(int math) {
Math= math;
}
public int SumAll(){
returnthis.Chinese+this.English+this.Math;
}
}
#使用ArrayList集合产生10个1-20之间不重复的随机数:
package ArrayList_Demo;
import java.util.ArrayList;
import java.util.Random;
public class ArrayList_Text01 {
public static void main(String[] args) {
Random r=new Random();//创建随机数生成器对象
ArrayList<Integer> al=new ArrayList<Integer>();//创建ArrayList集合对象,该集合泛型为Integer类型
int count=0;//定义统计变量
while(count<10){
int result=r.nextInt(20)+1;//产生1-20之间的随机数
if(!al.contains(result)){
al.add(result);
count++;
}
}
System.out.println("使用ArrayList集合产生10个1-20之间不重复的随机数");
for(Integer i:al){
System.out.print(i + " ");
}
}
}
七:用集合实现用户的注册与登录:
(1) 测试类
(2)package Xust.Text;
(3)import java.util.Scanner;
(4)importXust.Guess.GuessNumberPlay;
(5)import Xust.User.User;
(6)import Xust.dao.UserDao;
(7)importXust.dao.Impl.DaoImpl;
(8)
(9)public class Text {
(10) public static void main(String[]args) {
(11)
(12) System.out.println("------请用户作出选择-------");
(13) System.out.println("1 登录");
(14) System.out.println("2 注册");
(15) System.out.println("3 退出");
(16)
(17) while(true){
(18) Scanner Sc=new Scanner(System.in);
(19) System.out.println("请选择:");
(20) StringresultString=Sc.nextLine();
(21)
(22) UserDaoud=new DaoImpl();//由于在下面的switch语句中,isLogin()方法和register()方法都会用到该对象,所以将该对象定义在switch语句的外面
(23) switch(resultString){
(24) case "1"://登录页面
(25) System.out.println("请用户登录账号:");
(26) System.out.println("请输入用户名:");
(27) StringUsername=Sc.nextLine();
(28) System.err.println("请输入密码:");
(29) StringPassword=Sc.nextLine();
(30)
(31) Booleanflag=ud.islogin(Username, Password);
(32) if(flag){
(33) System.out.println("恭喜您,登录成功;接下来是游戏环节:");
(34) System.out.println("请选择是否玩游戏:y/n");
(35) while(true){
(36) StringChoiceString=Sc.nextLine();
(37) if(ChoiceString.equalsIgnoreCase("y")){
(38) GuessNumberPlay.Play();
(39) }else {
(40) break;
(41) }
(42) }
(43) System.out.println("欢迎使用,谢谢惠顾!");
(44) System.exit(0);//能够退出外层的while循环
(45) }
(46) else{
(47) System.out.println("您输入的有误!,请重新输入!");
(48) }
(49) break;
(50) case "2"://注册页面
(51) System.out.println("请您输入用户名:");
(52) StringnewUserName=Sc.nextLine();
(53) System.out.println("请您输入密码:");
(54) StringnewPassWord=Sc.nextLine();
(55)
(56) Userus=new User();//创建User类对象,将用户名和密码封装在该对象中
(57) us.setUsername(newUserName);
(58) us.setPassword(newPassWord);
(59)
(60) ud.regist(us);//调用用户注册方法
(61) System.out.println("恭喜您,账号注册成功:");
(62) System.out.println("请登录!");
(63)
(64) break ;//能够退出外层的while循环
(65) case "3":
(66) break;
(67) default:
(68) System.out.println("谢谢光临,下次再来!");
(69) System.exit(0);
(70) break;
(71) }
(72) }
(73) }
(74) }
(2)用户实体类:
package Xust.User;
/**
* 这是用户的实体类
* @author Lenovo
* @version 1.0
* */
public class User {
private String Username;
private String Password;
public User() {
super();
// TODO Auto-generatedconstructor stub
}
public String getUsername() {
return Username;
}
public void setUsername(String username) {
Username = username;
}
public String getPassword() {
return Password;
}
public void setPassword(String password) {
Password = password;
}
}
(3)用户的操作接口:
package Xust.dao;
import Xust.User.User;
/**
* 这是定义的一个用户操作接口,
* @author Lenovo
* @version 1.0
*
* Username:
* 传递的用户民
* PassWord:
* 传递的密码
* */
public interface UserDao {
public abstract boolean islogin(String Username,String Password);//定义用户登录方法
public abstract void regist(User user);//定义用户注册方法
}
(4)用户操作接口的子实现类:
package Xust.dao.Impl;
import Xust.User.User;
import java.util.ArrayList;
import Xust.dao.UserDao;
/**
* 这是定义的一个接口的子实现类,该类是业务逻辑层,
* @author Lenovo
* @version 1.0
*
*
* */
public class DaoImpl implements UserDao {
private static ArrayList<User> al=new ArrayList<User>();//将该集合对象进行私有化,防止外界修改
public boolean islogin(String Username, String Password) {
// TODO Auto-generatedmethod stub
boolean flag=false;
for(User u:al){
if(u.getUsername().equals(Username) &&u.getPassword().equals(Password)){//判断用户是否登录成功
flag=true;
return flag;
}
}
return flag;
}
@Override
public void regist(User user) {
// TODO Auto-generatedmethod stub
al.add(user);
}
}
(5)游戏类:
package Xust.Guess;
import java.util.Scanner;
public class GuessNumberPlay {
private GuessNumberPlay(){//私有化无参构造
super();
// TODO Auto-generatedconstructor stub
}
public static void Play(){
int number=(int) (Math.random()*100+1);//产生1-100之间的随机数
int count=0;
while(true){
Scanner Sc1=new Scanner(System.in);
System.out.println("请输入您猜的数:");
int a=Sc1.nextInt();
count ++;
if(a<number){
System.out.println("您猜的数小了,请重新输入!");
}
else if(a>number){
System.out.println("您猜的数大了,您重新输入!");
}
else{
System.out.println("您经过" + count + "次猜中了该数!");
}
}
}
}
4008
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
