用LinkedList模拟一个队列和一个栈 要求实现栈先进后出 和队列先进先出的特征
==================================================================================
编写一个Array数组 要求实现功能：去除数组内重复的元素
=======================================================================================
HashSet如何保证元素的唯一性？
是通过元素的两个方法 第一：判断HashCode的值是否相同，如果不同，则判断结束
如果相同...第二：调用元素的equals方法
在开发的过程中如果需要利用集合存大量的不允许重复的元素，则需要复写hashcode()和
equals方法
===============================================================================
TreeSet
自定义User类，属性为姓名和年龄。将自定义的User类插入到TreeSet集合中并实现排序
思路：TreeSet集合自动实现排序的原理是首先要求对象具有可比性，所以User类需要实现Comparable接口
User的两个属性 首先对年龄判断，再对姓名判断
代码如下：
========================================================================================
TreeSet实现排序的第二种方法 也就是在构造结合时将比较器对象作为参数传入到集合的构造方法当中
比较器类代码如下：
输出结果如下：
Kobe...34
Lin...24
Lin...31
Yao...31
kobe...34
可以看出 对姓名作为第一关键字年龄做为第二关键字进行了排序
小结：
实现对TreeSet排序一般用两种方法
在项目中常使用比较器方法
也就是 自定义一个比较器 要求实现Comparator接口
public class MyComparator implements Comparator
再覆写compare()方法
这种方式比较灵活可以自定义比较器
第二种方式是在构造集合中的类的时候 给类实现comparable接口 让类自身有可比性
需要覆写compareto()方法
public class User implements Comparable
public int compareTo(Object o)
=============================================================================
练习：按照字符串长度排序
思路 字符串长度为第一关键字 字符串的自然排序为第二关键字
用比较器实现 这样灵活 不用覆写String类自身的compareto方法
首先自定义Comparator类 实现Comparator接口
覆写compare()方法
package LinkedListDemo;
import java.util.*;
/**
* 利用LinkedList模拟一个简单的队列要求先进先出
* @author bing
* @version V1.0
*
*/
public class Queue {
private LinkedList link;
/**
* 够造函数，构造一个队列。
* @param link link是一个LinkedList型的对象。在构造队列时，生成一个LinkedList对象 用于以后的操作
*/
Queue()
{
link = new LinkedList();
}
/**
* 在队列的头部插入元素
* @param obj 插入的对象，插入在队列的头部
*/
public void myEnQueue(Object obj)
{
link.addFirst(obj);//在队列的头部插入元素
}
/**
*
* @return 返回取出的元素，取出的元素位于队列尾部
*/
public Object myDeQueue()
{
return link.removeLast();//在队列的尾部取出元素，保证了先进先出
}
/**
* 判断队列是否为空
* @return 返回ture则表示队列为空，false则表示队列内还有元素
*/
public boolean isNull()
{
return link.isEmpty();
}
public LinkedList getLink() {
return link;
}
public void setLink(LinkedList link) {
this.link = link;
}
}
package LinkedListDemo;
import java.util.LinkedList;
/**
* 利用LinkedList模拟一个栈 要求实现先进后出的特征
* @author bing
*
*/
public class Stack {
private LinkedList link;
Stack()
{
link = new LinkedList();
}
public void Push(Object obj)
{
link.addFirst(obj);
}
public Object Pop()
{
return link.removeFirst();
}
public LinkedList getLink() {
return link;
}
public void setLink(LinkedList link) {
this.link = link;
}
}
//测试程序如下
public static void main(String[] args) {
sop("验证队列");
Queue q = new Queue();
q.myEnQueue("java01");
q.myEnQueue("java02");
q.myEnQueue("java03");
q.myEnQueue("java04");
System.out.println(q.getLink());
Object ob = q.myDeQueue();
System.out.println(ob);
System.out.println(q.getLink());
sop("验证栈");
Stack s = new Stack();
s.Push("java -1");s.Push("java -2");s.Push("java -3");
sop(s.getLink());
sop(s.Pop());
sop(s.getLink())
输出结果为
验证队列
[java04, java03, java02, java01]
java01
[java04, java03, java02]
验证栈
[java -3, java -2, java -1]
java -3
[java -2, java -1]
==================================================================================
编写一个Array数组 要求实现功能：去除数组内重复的元素
package LinkedListDemo;
import java.util.*;
public class MyArrayList<E> extends ArrayList<E> {
public List deRepeatElement_1()
{
MyArrayList mal = new MyArrayList();
Iterator it =this.iterator();
while(it.hasNext())
{
Object obj = it.next();
if(!mal.contains(obj))
{
mal.add(obj);
}
}
return mal;
}
}
=======================================================================================
HashSet如何保证元素的唯一性？
是通过元素的两个方法 第一：判断HashCode的值是否相同，如果不同，则判断结束
如果相同...第二：调用元素的equals方法
在开发的过程中如果需要利用集合存大量的不允许重复的元素，则需要复写hashcode()和
equals方法
package Set;
import java.util.*;
/**
* 自定义类person，向HashSet中存入Person类型对象，如果年龄和性别都相同则
* 视作相同元素，不予存储。
* 这里需要复写Person类型的HashCode方法和equals方法
* @author bing
*
*/
public class Demo {
public static void main(String[] args) {
Person p1 = new Person("kobe",34);
Person p2 = new Person("kobe",34);
Person p3 = new Person("Yao",34);
Person p4 = new Person("Lin",24);
HashSet hs = new HashSet();
hs.add(p1);hs.add(p2);hs.add(p3);hs.add(p4);
System.out.println(hs);
Iterator it = hs.iterator();
while(it.hasNext())
{
Person op = (Person)it.next();
System.out.println(op.getName()+"----"+op.getAge());
}
}
}
package Set;
public class Person {
private String name;
private int age;
public Person(String name, int age) {
this.name = name;
this.age = age;
}
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 int hashCode() {
return 60;
}
@Override
public boolean equals(Object obj) {
Person p = (Person)obj;//向下塑形
if(!(obj instanceof Person))
{
System.out.println("类型不匹配");
return false;
}
else{
if(this.getName()==p.getName()&&this.getAge()==p.getAge())
{
return true;
}
else return false;
}
//return super.equals(obj);
}
}
/**
输出结果
[Set.Person@3c, Set.Person@3c, Set.Person@3c]
Lin----24
Yao----34
kobe----34
Person类里复写了HasCode方法 让Hash值都为固定值 然后进行equals判断 这样是为了演示HashSet类如何去除
重复元素的方法
*/
===============================================================================
TreeSet
自定义User类，属性为姓名和年龄。将自定义的User类插入到TreeSet集合中并实现排序
思路：TreeSet集合自动实现排序的原理是首先要求对象具有可比性，所以User类需要实现Comparable接口
User的两个属性 首先对年龄判断，再对姓名判断
代码如下：
package Set;
public class User implements Comparable{//强制让用户类具备比较性
private String name;
private int age;
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 User(String name, int age) {
//super();
this.name = name;
this.age = age;
}
@Override
public int compareTo(Object o) {
if(!(o instanceof User))
{
throw new RuntimeException("不是User对象");
}
User u = (User)o;
System.out.println(this.getName()+"compareto"+u.getName());
if(this.getAge()>u.getAge())
{
return 1;
}
else if(this.getAge()==u.getAge())
{
return(this.getName().compareTo(u.getName()));
//return 0;
}
return -1;
}
}
//测试程序如下
/**
* 向TreeSet集合中存储自定义对象
* 按照User的年龄（第一关键字）进行排序
* 再按照User的姓名（第二关键字）进行排序
*/
TreeSet ts = new TreeSet();
ts.add(new User("kobe",34));
ts.add(new User("Yao",31));
ts.add(new User("Lin",31));
Iterator ti = ts.iterator();
while(ti.hasNext())
{
User u = (User)ti.next();
System.out.println(u.getName()+"..."+u.getAge());
}
========================================================================================
TreeSet实现排序的第二种方法 也就是在构造结合时将比较器对象作为参数传入到集合的构造方法当中
比较器类代码如下：
package Set;
import java.util.Comparator;
public class MyComparator implements Comparator {
/**
* 实现对User类的排序
* 第一关键字name
* 第二关键字age
*/
@Override
public int compare(Object o1, Object o2) {
User u1 = (User)o1;
User u2 = (User)o2;
if(!(o1 instanceof User)&& !(o2 instanceof User))
{
throw new RuntimeException("存入的对象不是User类");
}
int num = u1.getName().compareTo(u2.getName());//按姓名为
//第一关键字排序
if(num == 0)//如果姓名是相同的，按年龄作为第二关键字排序，可以考虑将
//年龄包装成Integer类调用其自身的compareto方法
{
return new Integer(u1.getAge()).compareTo(new Integer(u2.getAge()));
}
return num;
}
}
//比较器的好处是用发比较灵活 在开发的过程中使用比较器的方法比较常用
//测试程序如下：
public static void main(String[] args) {
/**
* TreeSet实现排序的方法二 容器本身早构造时传入比较器Comparator
* 当元素自身不具备比较性，或者具备的比较性不是所需要的 ，这时需要将比较器
* 对象作为参数传递给TreeSet集合的构造函数
*/
TreeSet ts = new TreeSet(new MyComparator());
ts.add(new User("kobe",34));
ts.add(new User("Kobe",34));
ts.add(new User("Yao",31));
ts.add(new User("Lin",31));
ts.add(new User("Lin",24));
Iterator ti = ts.iterator();
while(ti.hasNext())
{
User u = (User)ti.next();
System.out.println(u.getName()+"..."+u.getAge());
}
}
输出结果如下：
Kobe...34
Lin...24
Lin...31
Yao...31
kobe...34
可以看出 对姓名作为第一关键字年龄做为第二关键字进行了排序
小结：
实现对TreeSet排序一般用两种方法
在项目中常使用比较器方法
也就是 自定义一个比较器 要求实现Comparator接口
public class MyComparator implements Comparator
再覆写compare()方法
这种方式比较灵活可以自定义比较器
第二种方式是在构造集合中的类的时候 给类实现comparable接口 让类自身有可比性
需要覆写compareto()方法
public class User implements Comparable
public int compareTo(Object o)
=============================================================================
练习：按照字符串长度排序
思路 字符串长度为第一关键字 字符串的自然排序为第二关键字
用比较器实现 这样灵活 不用覆写String类自身的compareto方法
首先自定义Comparator类 实现Comparator接口
覆写compare()方法
package Set;
import java.util.Comparator;
public class StrLenthComparator implements Comparator{
@Override
public int compare(Object o1, Object o2) {
String s1 = (String)o1;
String s2 = (String)o2;
if(s1.length()>s2.length())
{
return 1;
}else if(s1.length()<s2.length())
{
return -1;
}
return s1.compareTo(s2);
}
}
//测试程序如下
package Set;
import java.util.Iterator;
import java.util.TreeSet;
/**
* 练习：要求使用字符串长度作为关键字排序
* 思路 ：用比较器
* @author bing
*
*/
public class TreeSetExercise {
public static void main(String[] args) {
TreeSet ts = new TreeSet(new StrLenthComparator());
ts.add("ab");
ts.add("ac");
ts.add("acd");
ts.add("ABCd");
Iterator ti = ts.iterator();
while(ti.hasNext())
{
System.out.println(ti.next());
}
}
}
/**
* 输出结果
* ab
* ac
* acd
* ABCd
* 可以看出字符按照长度先排列，在字符的长度相同的情况下按照字符的自然顺序排序
*/
分享到：
发表评论
相关推荐
基本数据类型笔记.py
struts2学习笔记3数据类型转换struts2学习笔记3数据类型转换struts2学习笔记3数据类型转换struts2学习笔记3数据类型转换struts2学习笔记3数据类型转换struts2学习笔记3数据类型转换struts2学习笔记3数据类型转换
ABAP-数据类型学习笔记
本笔记主要关注C语言中的数据类型，这是理解任何编程语言的基础。数据类型决定了变量可以存储哪种类型的数据以及如何操作这些数据。在C语言中，数据类型大致可以分为以下几类： 1. 基本数据类型： - **整型**：...
ABAP提供八种固定长度的基本数据类型：D（日期）、F（浮点数）、I（整数）、C（字符）、N（数值文本）、P（定点数）、X（十六进制）和XSTRING（二进制）。其中，D、F、I无需指定长度，但C、N、X需要。对于P类型，...
1. **基本概念**：首先，笔记可能会定义数据结构的基本概念，如什么是数据、数据元素、数据对象、数据结构和抽象数据类型（ADT）。它会解释数据结构是如何组织和存储数据的，以及如何通过不同的方式访问和操作这些...
javaSE基础数据类型学习笔记
C语言学习笔记基础数据类型
本篇学习笔记将详细解析Java中的数据类型转换及其相关的知识点。 首先，我们需要了解Java的基本数据类型，它们分为两大类：整型和浮点型。整型包括byte、short、int和long，浮点型包括float和double。此外，还有...
"Java学习笔记，变量和数据类型和运算符" Java学习笔记中的变量和数据类型是 Java 语言的基础，了解 Java 的变量和数据类型是学习 Java 的必要步骤。 1. 数据类型 Java 中的数据类型可以分为基本数据类型和引用...
2. 数据类型：数据类型定义了一组值的集合以及定义在这个集合上的操作。原子类型包括基本的数据类型，如整型、浮点型、字符型等；结构类型是由若干原子类型组合而成的复杂类型，例如结构体。 3. 抽象数据类型（ADT...
郝斌数据结构笔记 数据结构概述： 数据结构是指在计算机中对数据的存储、组织和管理的方式。它是软件最核心的课程，学完了啥也干不了。数据结构 = 个体的存储 + 个体的关系存储，算法 = 对存储数据的操作。 知识点...
在文档笔记部分，读者可以期待对Python数据分析基础知识的深入解析，包括但不限于数据类型、数据结构、数据清洗、数据聚合、条件查询、时间序列分析等。笔记可能还会涵盖如何使用Pandas进行数据导入和导出，以及如何...
- Java中的基本数据类型包括`boolean`、`byte`、`char`、`short`、`int`、`long`、`float`、`double`等。 - 基本数据类型的大小及取值范围如下： | 类型名称 | 大小(bits) | 取值范围 | | -------- | ---------...
4. 抽象数据类型（ADT）： ADT是数学模型和定义在该模型上的操作集合，是一种高级的编程概念。它强调问题的抽象，定义了数据对象、数据关系和基本操作。ADT有助于封装复杂的数据操作，提高代码的可读性和可维护性。 ...
一个全面的关VC++数据类型的总结，VARIANT, _variant_t,COleVariant 转换成字符中及相互间转化 不同时间间转换
在这些笔记中，你会学到如何使用Pandas读取和预处理数据，包括处理缺失值、异常值、数据类型转换以及数据聚合等操作。同时，Numpy的矩阵运算和统计函数也会被深入讲解，这对于理解和处理复杂的数据模型至关重要。 ...
Java 基本数据类型详解 Java 是一种面向对象的编程语言，Java 语言中有两大类数据类型：基本数据类型和引用数据类型。基本数据类型是 Java 语言的基础，理解基本数据类型是学习 Java 的关键。 Java 基本数据类型有...
(一)数据元素、数据结构、抽象数据类型等概念 (二)算法设计的基本要求 (三)语句的频度和估算时间复杂度 二、线性表 (一)线性表的定义和基本操作 (二)线性表的实现 1.顺序存储结构 2.链式存储结构 3.线性表的应用 三...
在数据类型的采集方面，数据预处理笔记详细介绍了结构化数据、半结构化数据和非结构化数据的概念和采集方法。结构化数据可以使用关系型数据库表示和存储，通常表现为二维表形式，每一行数据代表一个实体的信息。半...