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);
        }
    }
}
时间： 2024-08-03 22:03:03

JAVASE02-Unit05： 集合操作 —— 查找表的相关文章

JAVASE02-Unit04： 集合框架 、 集合操作 —— 线性表

Unit04: 集合框架 . 集合操作 -- 线性表 操作集合元素相关方法 package day04; import java.util.ArrayList; import java.util.Collection; import day02.Point; /** * 操作集合元素相关方法 * @author adminitartor * */ public class Collection_Remove { public static void main(String[] args) { C

集合操作--线性表

1.ArrayList和LinkedList List接口是Collection的子接口,用于定义线性表数据结构. 可以将List理解为存放对象的数组,只不过其元素个数可以动态的增加或减少. List接口的两个常见实现类为ArrayList和LinkedList,分别用动态数组和链表的方式实现了List接口 可以认为ArrayList和LinkedList的方法在逻辑上完全一样,只是在性能上有一定的差别. ArrayList更适合于随机访问而LinkedList更适合于插入和删除. 在性能要求不

SQL查询初学者指南读书笔记(五)集合操作与多表查询介绍

PART III:Thinking in Sets CHAPTER7 Thinking in Sets The three mostcommon set operations are as follows. Intersection Difference Union 在SQL中相应的关键词分别是 Intersection Except Union 实际数据库实现一般支持以下相应的数据库集合操作 INNER JOIN OUTER JOIN UNION JOIN 不过其区别是前者集合操作涉及表中所有

ListGetandSetDemo 集合操作get set remove add方法

/** * 集合操作 --线性表 概念: List是Collection的子接口,用于定义线性表数据结构. * 可以将List理解为存放数据的数组.只不过个数可以动态的删除和增加. * * List有两个常用的实现类,ArrayList和LinkedList. 两者在功能上相同,只是性能上有些差异. * ArrayList是用动态数组的方式体现,更适合随机访问. * LinkedList是用链表的方式体现,更适合增删插入. 如果对性能要求不苛刻,可以忽略性能差异. * * List除了继承Col

静态查找表：顺序查找、折半查找、分块查找

引言: 除去各种线性和非线性的数据结构外.另一种在实际应用中大量使用的数据结构--查找表.查找表是由同一类型的数据元素构成的集合. 对查找表常常进行的操作有:1.查找某个"特定的"数据元素是否在查找表中:2.检索某个"特定的"数据元素的各种属性:3.在查找表中插入一个数据元素:4.从查找表中删去某个数据元素.对查找表仅仅作前两种统称为"查找"的操作,则称此类查找表为静态查找表. 若在查找过程中同一时候插入查找表中不存在的数据元素,或者从查找表中删

动态查找表

1.动态查找表的特点:表结构本身是在查找过程中动态生成的,即对于给定值key,若表中存在其关键字等于key的记录,则查找成功返回,否则插入关键字等于key的记录. 1 //---------------抽象数据类型动态查找表的定义--------------------- 2 ADT DynamicSearchTable{ 3 数据对象D:D是具有相同特性的数据元素的集合.各个数据元素均含有类型相同,可惟一标识数据元素的关键字. 4 数据关系R:数据元素同属一个集合. 5 基本操作P: 6 In

排序，分组和集合操作

排序操作 排序是计算机承担的最基本操作之一,尤其是在数据库处理领域,oracle也不例外.可能需要oracle排序数据的操作包括以下几种: (1)创建一个索引 (2)通过group by,unique或distinct关键字对数据进行分组或聚合 (3)因为使用order by子句使得数据按照排好的顺序返回 (4)使用排序合并方法联结表或结果集 (5)使用集合操作union,intersect或minus (6)执行特定的子查询 查询可能需要可观的资源,具体说明如下: CPU总是要消耗的.需要CP

Oracle基本语法&amp;&amp;函数&amp;&amp;子查询&amp;&amp;分页查询&amp;&amp;排序&amp;&amp;集合操作&amp;&amp;高级分组函数

一.  数据库 手工---文件管理---数据库 DB:Database 数据库. DBMS:管理数据库的软件.(oracle) 主流关系数据库: 1.      Oracle 2.      DB2 3.      SQL Server 基本没人使 4.      MySQL  基本没人用,免费 Linux 开源,可以发现漏洞补上 Windows服务器会有补丁,数据易泄漏 eclipse 日食 数据表(Table): 表的行(Row):记录 表的列(Column):字段 二.  关系型数据库 一

java常用的数组、字符串、集合操作以及数据结构与算法基本知识

java中常用封装的数组 .字符串. 集合来操作对象,但数据结构中常用的有栈和队列   数与图以及他们之间的排序,查找. 数组声明没有分配内存空间  只有创建或者是初始化时才分配,创建时把数组中的数据类型数据所在的内存空间首地址赋值给数组名,在创建每个对象时,都会给该对象分配地址和它存储的数据 .如变量    int arr[]; int arr[]={1,2,3};  arr=new int[10] ,int arr[][]={{1,9,7},{1,2,3}}  int arr[][]=new