JAVASE02-Unit05： 集合操作 —— 查找表
Unit05： 集合操作 —— 查找表
使用该类测试自定义元素的集合排序
package day05;
/**
* 使用该类测试自定义元素的集合排序
* @author adminitartor
*
*/
public class Point implements Comparable<Point>{
private int x;
private int y;
public Point(int x, int y) {
super();
this.x = x;
this.y = y;
}
public int getX() {
return x;
}
public void setX(int x) {
this.x = x;
}
public int getY() {
return y;
}
public void setY(int y) {
this.y = y;
} @Override
public String toString() {
return "("+x+","+y+")";
}
/**
* 该方法的作用是用来判断当前对象this与
* 参数给定的对象o之间比较大小的。
* 返回值不关注具体取值，只关注取值范围，
* 当:
* 返回值>0:当前对象大于参数对象(this>o)
* 返回值<0:当前对象小于参数对象
* 返回值=0:两个对象相等
*/
public int compareTo(Point o) {
int len = this.x*this.x+this.y*this.y;
int olen = o.x*o.x+o.y*o.y;
return len-olen;
} }
Point.java
排序自定义类型元素
package day05; import java.util.ArrayList;
import java.util.Collections;
import java.util.List; /**
* 排序自定义类型元素
* @author adminitartor
*
*/
public class SortListDemo1 {
public static void main(String[] args) {
List<Point> list
= new ArrayList<Point>();
list.add(new Point(3,4));
list.add(new Point(1,2));
list.add(new Point(5,7));
list.add(new Point(3,1));
list.add(new Point(6,2));
System.out.println(list);
/*
* Collections的sort方法要求集合元素
* 必须实现Comparable接口。
* 侵入性
*/
Collections.sort(list);
System.out.println(list);
}
}
SortListDemo1.java
排序字符串
package day05; import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List; /**
* 排序字符串
* @author adminitartor
*
*/
public class SortListDemo2 {
public static void main(String[] args) {
List<String> list
= new ArrayList<String>(); list.add("苍#null");
list.add("范老师");
list.add("小泽老师"); System.out.println(list); Comparator<String> com
= new Comparator<String>(){
public int compare(String o1, String o2) {
return o1.length()-o2.length();
} }; Collections.sort(list,com);
System.out.println(list); }
}
SortListDemo2.java
队列也可以存储一组元素，但是存取元素必须遵循
package day05; import java.util.LinkedList;
import java.util.Queue; /**
* java.util.Queue
* 队列
* 队列也可以存储一组元素，但是存取元素必须遵循
* 先进先出原则。
* @author adminitartor
*
*/
public class QueueDemo {
public static void main(String[] args) {
Queue<String> queue
= new LinkedList<String>();
/*
* boolean offer(E e)
* 入队操作，向队列末尾追加新元素
*/
queue.offer("one");
queue.offer("two");
queue.offer("three");
queue.offer("four"); System.out.println(queue);
/*
* E poll()
* 获取队首元素，获取后该元素即从队列
* 中被移除。
*/
String str = queue.poll();
System.out.println(str);
System.out.println(queue); /*
* E peek()
* 引用队首元素，获取后但不从队列中删除
*/
str = queue.peek();
System.out.println(str);
System.out.println(queue); //新循环遍历
for(String s : queue){
System.out.println(s);
}
System.out.println(queue); System.out.println("自行遍历开始!");
while(queue.size()>0){
str = queue.poll();
System.out.println(str);
}
System.out.println("遍历完毕了!");
System.out.println(queue);
}
}
QueueDemo.java
栈结构存储一组元素，但是存取需要遵循先进后出原则
package day05; import java.util.Deque;
import java.util.LinkedList; /**
* 栈
* 栈结构存储一组元素，但是存取需要遵循先进后出原则
*
* java.util.Deque
* 双端队列，两端都可以进出队的队列，是Queue的
* 子类。
* Deque接口规定了两端进出队的方法。
* 当仅调用从一端进出队的方法时，就形成了栈的结构特点
*
* @author adminitartor
*
*/
public class Stack {
public static void main(String[] args) {
Deque<String> stack
= new LinkedList<String>(); stack.offer("one");
stack.offer("two");
System.out.println(stack);//[one,two] stack.offerLast("three");
System.out.println(stack);//[one,two,three] stack.offerFirst("four");
System.out.println(stack);//[four,one,two,three] String str = stack.poll();
System.out.println(str);//four str = stack.pollFirst();
System.out.println(str);//one str = stack.pollLast();
System.out.println(str);//three System.out.println(stack); /*
* 双端队列提供了入栈与出栈的方法
*/
/*
* void push(E e)
* 入栈操作
* 最后入栈的元素会在栈顶
*/
stack.push("three");
stack.push("four");
stack.push("five");
System.out.println(stack); /*
* E pop()
* 出栈操作
* 获取栈顶元素后该元素即从栈中被移除
*/
str = stack.pop();
System.out.println(str);
System.out.println(stack); str = stack.peek();
System.out.println(str);
System.out.println(stack); for(String s : stack){
System.out.println(s);
}
System.out.println(stack); }
}
Stack.java
删除Map中的元素
package day05; import java.util.HashMap;
import java.util.Map; /**
* 删除Map中的元素
* @author adminitartor
*
*/
public class Map_Remove {
public static void main(String[] args) {
Map<String, Integer> map
= new HashMap<String, Integer>();
map.put("语文", 99);
map.put("数学", 98);
map.put("英语", 97);
map.put("物理", 96);
map.put("化学", 99); System.out.println(map);
/*
* 删除数学这一条记录
* V remove(K k)
* 根据给定的key将对应的key-value对
* 从Map中删除，返回值为该key对应的value
*/
Integer v = map.remove("数学");
System.out.println(map);
System.out.println(v);
}
}
Map_Remove.java
package day05; import java.util.HashMap;
import java.util.Map; /**
* 删除Map中的元素
* @author adminitartor
*
*/
public class Map_Remove {
public static void main(String[] args) {
Map<String, Integer> map
= new HashMap<String, Integer>();
map.put("语文", 99);
map.put("数学", 98);
map.put("英语", 97);
map.put("物理", 96);
map.put("化学", 99); System.out.println(map);
/*
* 删除数学这一条记录
* V remove(K k)
* 根据给定的key将对应的key-value对
* 从Map中删除，返回值为该key对应的value
*/
Integer v = map.remove("数学");
System.out.println(map);
System.out.println(v);
}
}
判断Map是否包含给定元素
package day05; import java.util.HashMap;
import java.util.Map; /**
* 判断Map是否包含给定元素
* @author adminitartor
*
*/
public class Map_Contains {
public static void main(String[] args) {
Map<String, Integer> map
= new HashMap<String, Integer>();
map.put("语文", 99);
map.put("数学", 98);
map.put("英语", 97);
map.put("物理", 96);
map.put("化学", 99); boolean ck = map.containsKey("语文");
System.out.println("key是否包含:"+ck); boolean cv = map.containsValue(99);
System.out.println("value是否包含:"+cv);
}
}
Map_Contains.java
package day05; import java.util.HashMap;
import java.util.Map; /**
* 判断Map是否包含给定元素
* @author adminitartor
*
*/
public class Map_Contains {
public static void main(String[] args) {
Map<String, Integer> map
= new HashMap<String, Integer>();
map.put("语文", 99);
map.put("数学", 98);
map.put("英语", 97);
map.put("物理", 96);
map.put("化学", 99); boolean ck = map.containsKey("语文");
System.out.println("key是否包含:"+ck); boolean cv = map.containsValue(99);
System.out.println("value是否包含:"+cv);
}
}
HashMap的Key对于HashMap的影响
package day05;
/**
* HashMap的Key对于HashMap的影响
* 影响HashMap的查询性能的主要因素是在HashMap中
* 出现链表。
* 那么作为Key的元素的hashcode值与equals比较的结果
* 在Map中产生链表有很大的作用。要妥善重写他们。
*
* API手册中Object对于hashcode方法与equals的重写
* 有如下要求:
* 1:当我们重写一个类的equals方法，就应当连同重写
* hashcode方法
* 2:hashcode应当与equals比较结果一致，即:
* 当两个对象equals比较结果为true时，他们的
* hashcode方法返回的数字应当相等。反之亦然。
* 因为当两个作为key的对象hashcode相同但是
* equals比较不相同时，会在HashMap中产生链表，
* 影响散列表查询性能。
*
*
* @author adminitartor
*
*/
public class Key {
private int x;
private int y;
@Override
public int hashCode() {
final int prime = 31;
int result = 1;
result = prime * result + x;
result = prime * result + y;
return result;
}
@Override
public boolean equals(Object obj) {
if (this == obj)
return true;
if (obj == null)
return false;
if (getClass() != obj.getClass())
return false;
Key other = (Key) obj;
if (x != other.x)
return false;
if (y != other.y)
return false;
return true;
} }
Key.java
Map 查找表,以key-value对的形式存储元素
package day05; import java.util.HashMap;
import java.util.Map; /**
* java.util.Map
* Map 查找表
* 以key-value对的形式存储元素
* 常用实现类:HashMap 散列表(散列算法实现)
* @author adminitartor
*
*/
public class Map_Put_Get {
public static void main(String[] args) {
/*
* Map需要指定两个泛型，分别指定key与
* value的类型
*/
Map<String,Integer> map
= new HashMap<String,Integer>(); /*
* Map要求key不允许重复(equals比较)
* V put(K k,V v)
* 将给定的key-value对存入到Map中，
* 若key在map中已经存在了，则是替换value
* 操作，返回至则为被替换的value
* 若key不存在，则返回值为NULL
*/
map.put("语文", 99);
map.put("数学", 98);
map.put("英语", 97);
map.put("物理", 96);
/*
* 获取put返回值时，若返回值为包装类类型
* 注意不要用基本类型接收，避免自动拆箱
* 引起的空指针异常:
* int n = map.put("化学",99);
* 因为若"化学"作为key在Map中不存在，put
* 返回值为NULL,那么对其拆箱会引发空指针
*/
Integer n = map.put("化学", 99); System.out.println(map);
System.out.println(n); //重复的key是替换value操作
n = map.put("语文", 88);
System.out.println(map);
System.out.println(n); /*
* V get(K k)
* 根据给定的key获取对应的value
* 若给定的key不存在，则返回值为null
*/
n = map.get("数学");
System.out.println("数学:"+n); n = map.get("体育");
System.out.println("体育:"+n); }
}
Map_Put_Get.java
package day05; import java.util.HashMap;
import java.util.Map; /**
* java.util.Map
* Map 查找表
* 以key-value对的形式存储元素
* 常用实现类:HashMap 散列表(散列算法实现)
* @author adminitartor
*
*/
public class Map_Put_Get {
public static void main(String[] args) {
/*
* Map需要指定两个泛型，分别指定key与
* value的类型
*/
Map<String,Integer> map
= new HashMap<String,Integer>(); /*
* Map要求key不允许重复(equals比较)
* V put(K k,V v)
* 将给定的key-value对存入到Map中，
* 若key在map中已经存在了，则是替换value
* 操作，返回至则为被替换的value
* 若key不存在，则返回值为NULL
*/
map.put("语文", 99);
map.put("数学", 98);
map.put("英语", 97);
map.put("物理", 96);
/*
* 获取put返回值时，若返回值为包装类类型
* 注意不要用基本类型接收，避免自动拆箱
* 引起的空指针异常:
* int n = map.put("化学",99);
* 因为若"化学"作为key在Map中不存在，put
* 返回值为NULL,那么对其拆箱会引发空指针
*/
Integer n = map.put("化学", 99); System.out.println(map);
System.out.println(n); //重复的key是替换value操作
n = map.put("语文", 88);
System.out.println(map);
System.out.println(n); /*
* V get(K k)
* 根据给定的key获取对应的value
* 若给定的key不存在，则返回值为null
*/
n = map.get("数学");
System.out.println("数学:"+n); n = map.get("体育");
System.out.println("体育:"+n); }
}
遍历Map
package day05; import java.util.Collection;
import java.util.HashMap;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set; /**
* 遍历Map
* 遍历Map有三种方式:
* 1:遍历所有的key
* 2:遍历每一组键值对
* 3:遍历所有的value(相对不常用)
* @author adminitartor
*
*/
public class MapDemo {
public static void main(String[] args) {
Map<String, Integer> map
= new HashMap<String, Integer>();
map.put("语文", 99);
map.put("数学", 98);
map.put("英语", 97);
map.put("物理", 96);
map.put("化学", 99); /*
* 遍历所有的key
* Set<K> keySet()
* 将当前Map中所有的key存入一个Set集合
* 后返回。遍历该集合就等于遍历了Map中
* 所有的key
*/
Set<String> keySet = map.keySet();
for(String key : keySet){
System.out.println("key:"+key);
} /*
* 遍历每一组键值对
* Map中每一组键值对由Map的内部类Entry
* 的一个实例保存。
* Set<Entry> entrySet()
* 该方法会将当前Map中每组键值对(若干的
* Entry实例)存入一个Set集合后返回
*/
Set<Entry<String,Integer>> entrySet
= map.entrySet();
for(Entry<String,Integer> e:entrySet){
String key = e.getKey();
Integer value = e.getValue();
System.out.println(key+":"+value);
} /*
* Collection<V> values()
* 该方法会返回当前Map中所有的value
*/
Collection<Integer> values
= map.values();
for(Integer value : values){
System.out.println("value:"+value);
}
}
}
MapDemo.java
package day05; import java.util.Collection;
import java.util.HashMap;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set; /**
* 遍历Map
* 遍历Map有三种方式:
* 1:遍历所有的key
* 2:遍历每一组键值对
* 3:遍历所有的value(相对不常用)
* @author adminitartor
*
*/
public class MapDemo {
public static void main(String[] args) {
Map<String, Integer> map
= new HashMap<String, Integer>();
map.put("语文", 99);
map.put("数学", 98);
map.put("英语", 97);
map.put("物理", 96);
map.put("化学", 99); /*
* 遍历所有的key
* Set<K> keySet()
* 将当前Map中所有的key存入一个Set集合
* 后返回。遍历该集合就等于遍历了Map中
* 所有的key
*/
Set<String> keySet = map.keySet();
for(String key : keySet){
System.out.println("key:"+key);
} /*
* 遍历每一组键值对
* Map中每一组键值对由Map的内部类Entry
* 的一个实例保存。
* Set<Entry> entrySet()
* 该方法会将当前Map中每组键值对(若干的
* Entry实例)存入一个Set集合后返回
*/
Set<Entry<String,Integer>> entrySet
= map.entrySet();
for(Entry<String,Integer> e:entrySet){
String key = e.getKey();
Integer value = e.getValue();
System.out.println(key+":"+value);
} /*
* Collection<V> values()
* 该方法会返回当前Map中所有的value
*/
Collection<Integer> values
= map.values();
for(Integer value : values){
System.out.println("value:"+value);
}
}
}
JAVASE02-Unit05： 集合操作 —— 查找表的更多相关文章
- JAVASE02-Unit04： 集合框架 、 集合操作 —— 线性表
Unit04: 集合框架 . 集合操作 -- 线性表 操作集合元素相关方法 package day04; import java.util.ArrayList; import java.util.Co ...
- Day05:集合操作——线性表(二) / 查找表 / 文件操作——File(一)
文件操作:https://www.cnblogs.com/wsnb8/p/11403626.html
- Day04:集合框架(下) / 集合操作——线性表(一)
对象转型 向上转型: 什么是向上造型? 子类对象赋给父类引用 父类引用指向子类对象 父类类型 引用=子类对象; 子类转成父类 默认进行(父类引用指用子类对象). 为什么需要向上造型? 子类对象可 ...
- C语言数据结构基础学习笔记——静态查找表
查找:在数据集合中寻找满足某种条件的数据元素的过程称为查找. 查找表:用于查找的数据集合称为查找表,一般有以下操作:①查找是否在表中:②查找属性:③进行操作. 查找表又分为: ①静态查找表:只可以进行 ...
- Map 查找表操作
package seday13; import java.util.HashMap; import java.util.Map; /** * @author xingsir * java.util.M ...
- DOM操作样式表及其兼容性
DOM操作样式表的时候,存在很多浏览器兼容上的问题,测试的时候用的是Firefox 28.0.IE11.IE8.Chrome.测试的时候发现,不兼容问题基本上都是IE8和非IE浏览器之家的问题,很多I ...
- day 69 orm操作之表关系,多对多,多对一(wusir总结官网的API)
对象 关系 模型 wusir博客地址orm官网API总结 django官网orm-API orm概要: ORM 跨表查询 class Book(models.Model): title = mod ...
- 查找->动态查找表->哈希表
文字描述 哈希表定义 在前面讨论的各种查找算法中,都是建立在“比较”的基础上.记录的关键字和记录在结构中的相对位置不存在确定的关系,查找的效率依赖于查找过程中所进行的比较次数.而理想的情况是希望不经过 ...
- 算法与数据结构(九) 查找表的顺序查找、折半查找、插值查找以及Fibonacci查找
今天这篇博客就聊聊几种常见的查找算法,当然本篇博客只是涉及了部分查找算法,接下来的几篇博客中都将会介绍关于查找的相关内容.本篇博客主要介绍查找表的顺序查找.折半查找.插值查找以及Fibonacci查找 ...
随机推荐
- iOS 获取键盘view 覆盖新view
UIWindow *window = [[[UIApplication sharedApplication] windows] lastObject]; UIView * keyview=[[w ...
- 关于装完系统出现a disk read error occurred的解决方法
今天偶遇一台老电脑,很久都没有用了,而且只有几百兆的内存,160G的硬盘,无奈只好装XP系统,GHOST完之后,开机发现出现a disk read error occurred的错误,但是用U盘引导可 ...
- 【Jsoup网页解析】
下载链接:http://jsoup.org/download 一.普通的请求方式(不带有cookie) 使用举例: 第一步: Connection conn=Jsoup.connect(url); 第 ...
- jQuery和AngularJS的区别小分析
最近一直在研究angularjs,最大的感受就是它和之前的jQuery以及基于jQuery的各种库设计理念完全不同,如果不能认识到这点而对于之前做jQuery开发的程序员,去直接学习angularjs ...
- netfilter的钩子——数据包在内核态得捕获、修改和转发
转发:http://blog.csdn.net/stonesharp/article/details/27091391 数据包在内核态得捕获.修改和转发(基于 netfilter) 忙活了好几天 ...
- [Repost]Events and Signals in PyQt4
Reference:http://zetcode.com/gui/pyqt4/eventsandsignals/ Events and Signals in PyQt4 In this part of ...
- 【转】hibernate缓存：一级缓存和二级缓存
什么是缓存? 缓存是介于物理数据源与应用程序之间,是对数据库中的数据复制一份临时放在内存中的容器,其作用是为了减少应用程序对物理数据源访问的次数,从而提高了应用程序的运行性能.Hibernate在进行 ...
- one_person年轻的程序员
回顾大学三年,通过良师的教导和自身的刻苦学习,我已初步掌握如何运用计算机编程,也养成了认真对待学习和工作的好习惯! 在思想品德上,本人有良好道德修养,并有坚定的政治方向.我热爱祖国,热爱人民,遵纪守法 ...
- 【BO】WEBI文件打开时提示Illegal access错误
在infoview中打开WEBI文件时,提示如下错误. 通过查看SCN,找到错误原因是CMC中有一个服务没有启动. 启动这个服务即可: WebIntelligenceProcessingServer
- CI框架如何在主目录application目录之外使用uploadify上传插件和bootstrap前端框架：
19:29 2016/3/10CI框架如何在主目录application目录之外使用uploadify上传插件和bootstrap前端框架:项目主路径:F:\wamp\www\graduationPr ...