关注永雏塔菲喵
关注永雏塔菲喵

韩顺平Java自学笔记 集合

一。集合的概述

1.集合的好处与理解

数组存储数据的灵活性不够。

集合的好处 

韩顺平Java自学笔记 集合_第1张图片

2。集合的框架图

idea的diagram怎么用

Collection的实现子类

很重要（方便理解集合整体架构）

韩顺平Java自学笔记 集合_第2张图片

 解读：单列集合

在集合当中放的是单独的一个数据。List和Set都是单列集合

 Map接口及其常用的实现子类

韩顺平Java自学笔记 集合_第3张图片

 解读：双列集合

 在集合当中放的是键值对。存放的为K-V数据。

代码

package com.collection;

import java.util.ArrayList;
import java.util.HashMap;

public class Collection_ {
    public static void main(String[] args) {
        ArrayList arrayList = new ArrayList();
//      放一个数据为单列集合
        arrayList.add("jack");
        arrayList.add("tom");

        HashMap hashMap = new HashMap();
//      放两个数据，为双列集合
        hashMap.put(1,"北京");
        hashMap.put(2,"上海");
    }
}

二.Collection接口

1.Collection接口和常用方法

选用他的实现子类来讲解接口当中的方法 

 韩顺平Java自学笔记 集合_第4张图片

 代码

package com.collection;

import java.util.ArrayList;

public class CollectionMethod {
    public static void main(String[] args) {
        ArrayList objects = new ArrayList<>();
//        add增加元素 会自动装箱和自动拆箱
        objects.add("jack");
        objects.add(10);
        objects.add(true);
//      打印集合
        System.out.println("List = "+objects);
//        remove删除指定的元素
        objects.remove(0);  //删除第一元素
        objects.remove(true);
        System.out.println("List = "+objects);
//      contain查找有没有这个元素
        System.out.println(objects.contains("jack"));
//        size返回元素的个数
        System.out.println(objects.size());
//        判断元素是不是空的
        System.out.println(objects.isEmpty());
//        对元素进行清空
        objects.clear();
        System.out.println("List = "+objects);
//        添加多个元素
        ArrayList list2 = new ArrayList();
        list2.add("红楼梦");
        list2.add("水浒传");
        list2.add("三国演义");
        list2.add("西游记");
        objects.addAll(list2);
        System.out.println("List = "+objects);
//        查找多个元素是否存在
        System.out.println(objects.containsAll(list2));
//       删除多个元素
        objects.add("聊斋");
        objects.removeAll(list2);
        System.out.println("List = "+objects);
    }
}


执行结果




List = [jack, 10, true]
 List = [10]
 false
 1
 false
 List = []
 List = [红楼梦, 水浒传, 三国演义, 西游记]
 true
 List = [聊斋]




2.元素的遍历


迭代器迭代


韩顺平Java自学笔记 集合_第5张图片


迭代器的原理


韩顺平Java自学笔记 集合_第6张图片




 如果next没有元素,执行方法会出现异常韩顺平Java自学笔记 集合_第7张图片




使用迭代器进行遍历


package com.collection;

import java.util.ArrayList;
import java.util.Iterator;

public class CollectionIterator {
    public static void main(String[] args) {
        ArrayList arrayList = new ArrayList();
        arrayList.add(new Book("小李飞刀","古龙",10));
        arrayList.add(new Book("三国演义","罗贯中",20));
        arrayList.add(new Book("红楼梦","曹雪芹",30));

        System.out.println("数组 = "+arrayList);

//        现在希望能够遍历集合
//        1.得到迭代器
        Iterator iterator = arrayList.iterator();
        while (iterator.hasNext()){
//            返回的是Object类  编译类型是Object运行类型是什么类型就是什么类型
            Object next = iterator.next();
            System.out.println(next);
//            教大家一个快捷键itit
        }
//        当退出while循环后，游标不能再向下走了iterator已经指向了最后的元素。
//        如果希望再次遍历，要重置迭代器  再创建一个新的迭代器就好了
        iterator = arrayList.iterator();
        while (iterator.hasNext()) {
            Object next = iterator.next();
            System.out.println(next);
        }
    }
}

class Book{
    private String name;
    private String author;
    private double price;

    public Book() {
    }

    public Book(String name, String author, double price) {
        this.name = name;
        this.author = author;
        this.price = price;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getAuthor() {
        return author;
    }

    public void setAuthor(String author) {
        this.author = author;
    }

    public double getPrice() {
        return price;
    }

    public void setPrice(double price) {
        this.price = price;
    }

    @Override
    public String toString() {
        return "Book{" +
                "name='" + name + '\'' +
                ", author='" + author + '\'' +
                ", price=" + price +
                '}';
    }
}



执行结果




数组 = [Book{name='小李飞刀', author='古龙', price=10.0}, Book{name='三国演义', author='罗贯中', price=20.0}, Book{name='红楼梦', author='曹雪芹', price=30.0}]
 Book{name='小李飞刀', author='古龙', price=10.0}
 Book{name='三国演义', author='罗贯中', price=20.0}
 Book{name='红楼梦', author='曹雪芹', price=30.0}
 Book{name='小李飞刀', author='古龙', price=10.0}
 Book{name='三国演义', author='罗贯中', price=20.0}
 Book{name='红楼梦', author='曹雪芹', price=30.0}




使用增强for循环进行遍历


代码


package com.collection;

import java.util.ArrayList;

public class CollectionFor {
    public static void main(String[] args) {
        ArrayList arrayList = new ArrayList();
        arrayList.add(new Book("小李飞刀","古龙",10));
        arrayList.add(new Book("三国演义","罗贯中",20));
        arrayList.add(new Book("红楼梦","曹雪芹",30));

//        直接使用增强for循环，不仅能用于集合，还可以用于数组。  底层依旧是迭代器 可以理解为一个简化版的迭代器
        for (Object o : arrayList) {
            System.out.println(o);
        }
    }
}


结果




Book{name='小李飞刀', author='古龙', price=10.0}
 Book{name='三国演义', author='罗贯中', price=20.0}
 Book{name='红楼梦', author='曹雪芹', price=30.0}




课堂练习


韩顺平Java自学笔记 集合_第8张图片


 代码


package com.collection;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

public class CollectionTest {
    public static void main(String[] args) {
//        ArrayList实现了List所以可以这样写，接口讲过
        List list = new ArrayList();
        
        list.add(new Dog(10,"小黑狗"));
        list.add(new Dog(11,"大狼狗"));
//      使用增强for循环
        for (Object o : list) {
            System.out.println(o);
        }
//      使用迭代器
        Iterator iterator = list.iterator();
        while (iterator.hasNext()){
            Object next = iterator.next();
            System.out.println(next);
        }
    }
}


结果




Dog{age=10, name='小黑狗'}
 Dog{age=11, name='大狼狗'}
 Dog{age=10, name='小黑狗'}
 Dog{age=11, name='大狼狗'}




 三.List接口及常用方法


1.List接口介绍


类图


韩顺平Java自学笔记 集合_第9张图片




基本介绍




创建一个List集合对象


package com.list;

import java.util.ArrayList;

public class List_ {
    public static void main(String[] args) {
        ArrayList list = new ArrayList();
//      list集合是有顺序的，及添加顺序与输出的顺序是一致的   并且其中的元素是可以重复的
        list.add("小明");
        list.add("小红");
        list.add("小白");
        list.add("小牛");
        list.add("小杨");
//      支持索引索引从0开始
        System.out.println("list = "+list);
        System.out.println("list（0） = "+list.get(0));
        
//        list接口的实现类还有很多，只是有些老师没有讲  实现的方法也有很多
    }
}



结果




list = [小明, 小红, 小白, 小牛, 小杨]
 list（0） = 小明




2.List接口的方法






代码


package com.list;

import java.util.ArrayList;
import java.util.List;

public class ListMethod {
    public static void main(String[] args) {
        ArrayList list = new ArrayList();

        list.add("张三丰");
        list.add("贾宝玉");

//        在指定的位置插入元素
        list.add(1,"韩顺平");
        System.out.println("list = "+list);

//        再指定的位置将所有的元素插进去
        ArrayList list1 = new ArrayList();

        list1.add("林黛玉");
        list1.add("秦可卿");

        list.addAll(1,list1);
        System.out.println("list = "+list);
//        返回这个对象在集合当中首次出现的地方
        System.out.println(list.indexOf("林黛玉"));
//        返回在集合当中最后出现的位置
        list.add("韩顺平");
        System.out.println(list.lastIndexOf("韩顺平"));

//        移除指定位置的元素  并返回此元素
        list.remove(0);
        System.out.println("list = "+list);
//        替换指定位置的元素  如果不存在报异常
        list.set(0,"黛玉");
        System.out.println("list = "+list);
//        返回从一处到另一处的子集合  前闭后开
        List list2 = list.subList(0, 3);
        System.out.println(list2);
    }
}


结果




list = [张三丰, 韩顺平, 贾宝玉]
 list = [张三丰, 林黛玉, 秦可卿, 韩顺平, 贾宝玉]
 1
 5
 list = [林黛玉, 秦可卿, 韩顺平, 贾宝玉, 韩顺平]
 list = [黛玉, 秦可卿, 韩顺平, 贾宝玉, 韩顺平]
 [黛玉, 秦可卿, 韩顺平]




3.课堂练习


韩顺平Java自学笔记 集合_第10张图片


代码


package com.list;


import java.util.ArrayList;
import java.util.Iterator;

public class ListExercise {
    public static void main(String[] args) {
        ArrayList list = new ArrayList();
        for (int i=0;i<12;i++){
            list.add("hello"+i);
        }
        System.out.println("list = "+list);
        list.set(1,"韩顺平教育");
        System.out.println(list.get(4));
        list.remove(6);
        System.out.println("list = "+list);
        list.set(6,"红楼梦");
        System.out.println("list = "+list);
        Iterator iterator = list.iterator();
        while (iterator.hasNext()) {
            Object next = iterator.next();
            System.out.println(next);
        }
    }
}


结果




list = [hello0, hello1, hello2, hello3, hello4, hello5, hello6, hello7, hello8, hello9, hello10, hello11]
 hello4
 list = [hello0, 韩顺平教育, hello2, hello3, hello4, hello5, hello7, hello8, hello9, hello10, hello11]
 list = [hello0, 韩顺平教育, hello2, hello3, hello4, hello5, 红楼梦, hello8, hello9, hello10, hello11]
 hello0
 韩顺平教育
 hello2
 hello3
 hello4
 hello5
 红楼梦
 hello8
 hello9
 hello10
 hello11




4.三种list遍历方式的汇总


韩顺平Java自学笔记 集合_第11张图片


 代码


package com.list;

import java.util.*;

public class ListFor {
    public static void main(String[] args) {
//        三种数据的存储的方法都是可以的  因为都是List的实现的子类
//        ArrayList list = new ArrayList();
//        List list = new Vector();
        List list = new LinkedList();
        list.add("林黛玉");
        list.add("薛宝钗");
        list.add("王熙凤");
        list.add("秦可卿");
        list.add("贾元春");
//使用迭代器进行遍历
        Iterator iterator = list.iterator();
        while (iterator.hasNext()) {
            Object next = iterator.next();
            System.out.println(next);
        }
        System.out.println("====增强for循环=====");
        for (Object o : list) {
            System.out.println(o);
        }
        System.out.println("=====普通for循环=====");
        for (int i =0 ;i


结果




林黛玉
 薛宝钗
 王熙凤
 秦可卿
 贾元春
 =========
 林黛玉
 薛宝钗
 王熙凤
 秦可卿
 贾元春
 ==========
 林黛玉
 薛宝钗
 王熙凤
 秦可卿
 贾元春




5.练习题2


韩顺平Java自学笔记 集合_第12张图片


代码




package com.list;


import java.util.ArrayList;
import java.util.List;

public class ListExercise1 {
    public static void main(String[] args) {
        List arrayList = new ArrayList();
        arrayList.add(new Book1("小李飞刀","古龙",10));
        arrayList.add(new Book1("三国演义","罗贯中",40));
        arrayList.add(new Book1("红楼梦","曹雪芹",30));

        for (Object o : arrayList) {
            System.out.println(o);
        }

//        进行冒泡排序
        sort(arrayList);
        System.out.println("===排序后====");

        for (Object o : arrayList) {
            System.out.println(o);
        }
    }
//        使用冒泡进行排序
    public static void sort(List list){
        int size = list.size();
//        一共进行size-1轮比较
        for (int i=0;ibook11.getPrice()){

                    list.set(j,book11);
                    list.set(j+1,book1);
                }
            }
        }
    }
}
class Book1{
    private String name;
    private String author;
    private double price;

    public Book1() {
    }

    public Book1(String name, String author, double price) {
        this.name = name;
        this.author = author;
        this.price = price;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getAuthor() {
        return author;
    }

    public void setAuthor(String author) {
        this.author = author;
    }

    public double getPrice() {
        return price;
    }

    public void setPrice(double price) {
        this.price = price;
    }

    @Override
    public String toString() {
        return "名称:\t\t" +
                 name +
                "  作者:\t\t" + author +
                "  价格:\t\t" + price ;
    }
}




运行结果




名称:        小李飞刀  作者:        古龙  价格:        10.0
 名称:        三国演义  作者:        罗贯中  价格:        40.0
 名称:        红楼梦  作者:        曹雪芹  价格:        30.0
 ===排序后====
 名称:        小李飞刀  作者:        古龙  价格:        10.0
 名称:        红楼梦  作者:        曹雪芹  价格:        30.0
 名称:        三国演义  作者:        罗贯中  价格:        40.0




冒泡排序C语言版


ArrayList的注意事项


韩顺平Java自学笔记 集合_第13张图片




代码 


package com.collection;

import java.util.ArrayList;

public class CollectionDetail {
    public static void main(String[] args) {
//        是线程不安全的  多线程不建议使用
        ArrayList list = new ArrayList();
//       空对象也是可以放进去的
        list.add(null);
        list.add("小王");
        System.out.println(list);
    }
}



运行结果 




[null, 小王]




线程不安全的原因


什么是线程安全


最直观的是没有synchronized关键字修饰


韩顺平Java自学笔记 集合_第14张图片


Array List的底层代码逻辑分析


 扩容的解析


韩顺平Java自学笔记 集合_第15张图片


transient表示短暂的，瞬时的，表示改代码不会被序列化


什么是序列化https://blog.csdn.net/weixin_45858542/article/details/121871998?ops_request_misc=%257B%2522request%255Fid%2522%253A%2522166113686516782246490800%2522%252C%2522scm%2522%253A%252220140713.130102334..%2522%257D&request_id=166113686516782246490800&biz_id=0&utm_medium=distribute.pc_search_result.none-task-blog-2~all~top_positive~default-1-121871998-null-null.142%5Ev42%5Epc_rank_34_queryrelevant25,185%5Ev2%5Econtrol&utm_term=%E5%BA%8F%E5%88%97%E5%8C%96&spm=1018.2226.3001.4187


底层代码执行示意图


Map的详解


Map与set的原理大同小异，只是set当中的v是默认常量。


Map接口的常用类型（jdk8版本的）




 代码


package com.map_;

import java.util.HashMap;
import java.util.Map;

public class Map_ {
    public static void main(String[] args) {
//        1.用于保存存在映射关系的元素 K-V
//        2.Map当中的K与V可以是任意的引用类型对象，会封装到HashMap$Node对象当中
//        3.Map当中的K是不可以重复的，原因和HashSet一样
//        4.Map当中的V可以重复
//        5.Map当中的K和V都可以是null但是K为null只能有一个。
//        6.常用的K类型为String
        Map map = new HashMap();

        map.put("no1","韩顺平");
        map.put("no2","张无忌");
        map.put("no2","光头强");//当有相同的k时，就会对v进行替换。
        map.put(null,null);
        map.put(null,"小明");
//        通过get方法，传入对应的K,会得到Value.
        System.out.println(map.get("no2"));

        System.out.println("Map = "+map);
    }
}



运行结果




光头强
 Map = {no2=光头强, null=小明, no1=韩顺平}




双列元素，底层依旧是HashMap，存放没有顺序。


会封装到HashMap$Node对象当中


key是不可以重复的，与HashSet一样，当V重复时，会对v进行替换，V是可以重复的。以k来判断存储的元素是不是一样的。k与v一对一对应，通过k找到v。


 transient关键字


源码，追进去，进行分析。


数据真正存放的位置还是HashMap$Node当中，Map接口提供的操作Key与Value的方法，操作的都是引用，存放Key引用的集合为Set，存放Value引用的集合为Collection。


韩顺平Java自学笔记 集合_第16张图片




代码


package com.map_;

import java.util.Collection;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;

public class MapSource {
    public static void main(String[] args) {
        Map map = new HashMap();

        map.put("no1","韩顺平");
        map.put("no2","张无忌");
        map.put(new Car(),new Person());
        //老韩解读
//        1.最后K-V数据放到HashMap$Node的Node当中了
//        2.方便程序源码遍历创建了EntrySet集合 存放的元素为Entry，而Entry当中包含了K-V。Entry当中的K-V是指向了Node当中
//        的K-V而不是复制了一份。
//        3.EntrySet实现的存放的实际类型来时HashMap$Node因为Node是Map.entry的实现类
//        4.Map.Entry提供了两个重要的方法，getKey和getValue来获得K和V
        Set set = map.entrySet();
        System.out.println(set.getClass());

        for (Object o : set) {
           Map.Entry entry = (Map.Entry) o;
            System.out.println(entry.getKey()+"-"+entry.getValue());
        }
//      具体是什么类型可以通过class来获得
        Set set1 = map.keySet();
        System.out.println(set1.getClass());
        Collection values = map.values();
        System.out.println(values.getClass());

    }
}

class Car{

}
class Person{}


运行结果 




class java.util.HashMap$EntrySet
 no2-张无忌
 no1-韩顺平
 [email protected]_.Person@4554617c
 class java.util.HashMap$KeySet
 class java.util.HashMap$Values 




Map接口和常用方法


韩顺平Java自学笔记 集合_第17张图片


代码


package com.map_;

import java.util.HashMap;
import java.util.Map;

public class MapMethod {
    public static void main(String[] args) {
        Map map = new HashMap();

        map.put("邓超",new Book("",100));
        map.put("邓超","孙俪");  //会进行替换
        map.put("宋喆","马蓉");
        map.put("王宝强","马蓉");
        map.put("刘令博",null);
        map.put(null,"刘亦菲");
        map.put("鹿晗","关晓彤");
//      根据键来删除对应关系remove
        map.remove(null);
        System.out.println("map = "+map);
//        根据K来得到V，get
        Object val = map.get("鹿晗");
        System.out.println(val);
//        根据size来获得元素的个数
        System.out.println(map.size());
//        判断个数是否为0
        System.out.println(map.isEmpty());
//      对键值对进行清空
        map.clear();
        System.out.println("map = "+map);
//        判断键是否存在  还有同样的判断值的方法
        map.put("hsp","关晓彤");
        System.out.println(map.containsKey("hsp"));
    }
}

class Book{
    private String name;
    private int num;

    public Book(String name, int num) {
        this.name = name;
        this.num = num;
    }
}



运行结果 




map = {邓超=孙俪, 宋喆=马蓉, 刘令博=null, 王宝强=马蓉, 鹿晗=关晓彤}
 关晓彤
 5
 false
 map = {}
 true




Map接口的六种遍历方式


韩顺平Java自学笔记 集合_第18张图片


三种遍历方式，和存储的结构有关系


韩顺平Java自学笔记 集合_第19张图片


一种通过Set取Key，一种通过Collection取Value，一种通过Entry来取K-V。


韩顺平Java自学笔记 集合_第20张图片


 代码


package com.map_;

import java.util.*;

public class MapFor {
    public static void main(String[] args) {
        Map map = new HashMap();

        map.put("邓超","孙俪");  //会进行替换
        map.put("宋喆","马蓉");
        map.put("王宝强","马蓉");
        map.put("刘令博",null);
        map.put(null,"刘亦菲");
        map.put("鹿晗","关晓彤");

//        取出所有Key的值再通过key取出所有的value
        Set set = map.keySet();
//        (最简单)增强for循环
        for (Object key : set) {
            System.out.println(key +"-"+map.get(key));
        }
        System.out.println("=====使用迭代器   第一种====");
//        通过迭代器
        Iterator iterator = set.iterator();
        while (iterator.hasNext()){
            Object key = iterator.next();
            System.out.println(key +"-"+map.get(key));
        }
        System.out.println("=======取出所有的value 增强for 第二种========");
//        一次性取出所有的V
        Collection values = map.values();
        for (Object value : values) {
            System.out.println(value);
       }
//        Collection都可以用values
        System.out.println("=======取出所有的value 迭代器  第三种========");
        Iterator iterator1 = map.values().iterator();
        while (iterator1.hasNext()) {
            Object value =  iterator1.next();
            System.out.println(value);
        }
//     通过EntrySet来获得
        Set set1 = map.entrySet();
        System.out.println("=======使用EntrySet 的增强for循环，第三种========");
        for (Object o : set1) {
            Map.Entry map1 = (Map.Entry) o;
            System.out.println(map1.getKey()+"-"+map1.getValue());
        }
        System.out.println("=======迭代器  第四种========");
//        此时迭代器当中的类型是Node -》Entry
        Iterator iterator2 = set1.iterator();
        while (iterator2.hasNext()) {
            Object next = iterator2.next();
//          将得到的Object转型为Entry
            Map.Entry map1 = (Map.Entry) next;
            System.out.println(map1.getKey()+"-"+map1.getValue());
        }
    }
}


运行结果




邓超-孙俪
 宋喆-马蓉
 刘令博-null
 null-刘亦菲
 王宝强-马蓉
 鹿晗-关晓彤
 ===============
 邓超-孙俪
 宋喆-马蓉
 刘令博-null
 null-刘亦菲
 王宝强-马蓉
 鹿晗-关晓彤
 =======取出所有的value 增强for========
 孙俪
 马蓉
 null
 刘亦菲
 马蓉
 关晓彤
 =======取出所有的value 迭代器========
 孙俪
 马蓉
 null
 刘亦菲
 马蓉
 关晓彤
 =======使用EntrySet 的增强for循环，第三种========
 邓超-孙俪
 宋喆-马蓉
 刘令博-null
 null-刘亦菲
 王宝强-马蓉
 鹿晗-关晓彤
 =======迭代器========
 邓超-孙俪
 宋喆-马蓉
 刘令博-null
 null-刘亦菲
 王宝强-马蓉
 鹿晗-关晓彤




课堂练习


韩顺平Java自学笔记 集合_第21张图片


代码实现


package com.map_;

import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;

public class MapExercise {
    public static void main(String[] args) {
        Map map = new HashMap();

         map.put(1,new Emp("jack",100000,1));
         map.put(2,new Emp("tom",1000,1));
         map.put(3,new Emp("milan",12000,1));

//         使用KeySet 进行遍历
        System.out.println("======第一种遍历方式======");
        Set set = map.keySet();
        for (Object  key: set) {
            Emp emp  = (Emp) map.get(key);
            if (emp.getSal()>10000){
                System.out.println(emp);
            }
        }
//         使用EntryMap 进行遍历
        System.out.println("======第二种遍历方式======");
        Set set1 = map.entrySet();
        Iterator iterator = set1.iterator();
        while (iterator.hasNext()) {
            Object next = iterator.next();
//            得到Entry对象
            Map.Entry map1 = (Map.Entry) next;
//            Entry对象的values的值为Emp
            Emp emp = (Emp) map1.getValue();
            if (emp.getSal()>10000){
                System.out.println(emp);
            }
        }
    }
}

class Emp{
    private String name;
    private double sal;
    private int age;

    public Emp(String name, double sal, int age) {
        this.name = name;
        this.sal = sal;
        this.age = age;
    }

    public Emp() {
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public double getSal() {
        return sal;
    }

    public void setSal(double sal) {
        this.sal = sal;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "emp{" +
                "name='" + name + '\'' +
                ", sal=" + sal +
                ", age=" + age +
                '}';
    }
}





结果 




======第一种遍历方式======
 emp{name='jack', sal=100000.0, age=1}
 emp{name='milan', sal=12000.0, age=1}
 ======第二种遍历方式======
 emp{name='jack', sal=100000.0, age=1}
 emp{name='milan', sal=12000.0, age=1}




体现了一种包装的思想，包装到emp当中包装到了map当中，再包装到Entry当中


HashMap知识点小结


韩顺平Java自学笔记 集合_第22张图片


关于第五条的源码解释：如果添加相同的key则v会进行替换，下面会解释对比的原理。


HashMap的底层以及源码解析


放到table数组的那个位置，是根据hashcode的值随机的进行分配的


韩顺平Java自学笔记 集合_第23张图片


 HashSet的底层是HashMap,所以扩容机制是相同的,树的查询效率是非常的高的




关于HashMap的详解https://blog.csdn.net/woshimaxiao1/article/details/83661464?ops_request_misc=%257B%2522request%255Fid%2522%253A%2522166203910716782248570342%2522%252C%2522scm%2522%253A%252220140713.130102334..%2522%257D&request_id=166203910716782248570342&biz_id=0&utm_medium=distribute.pc_search_result.none-task-blog-2~all~top_positive~default-1-83661464-null-null.142%5Ev44%5Epc_rank_34_queryrelevant25&utm_term=hashmap&spm=1018.2226.3001.4187链接内容节选：


数组：数据的存储方式，一段连续的储存空间。查找当中存储的元素。1.制定下标查找。2.通过给定的值进行查找，要逐个比较数组元素，时间复杂度O(n)。对于有序的算法，可以利用算法来进行优化，如：则可采用二分查找，插值查找，斐波那契查找等方式，可将查找复杂度提高为O(logn)；对于一般的插入删除操作，涉及到数组元素的移动，其平均复杂度也为O(n)


线性链表：对于链表的新增，删除等操作（在找到指定操作位置后），仅需处理结点间的引用（具体可以去看数据结构）即可，时间复杂度为O(1)，而查找操作需要遍历链表逐一进行比对，复杂度为O(n)，链表利于增删不利于查找。


哈希表：哈希表中进行添加，删除，查找等操作，性能十分之高，不考虑哈希冲突的情况下（后面会探讨下哈希冲突的情况），仅需一次定位即可完成，时间复杂度为O(1)，接下来我们就来看看哈希表是如何实现达到惊艳的常数阶O(1)的。


HashMap增加元素


package com.map_;

import java.util.HashMap;

public class HashMapSource {
    public static void main(String[] args) {
        HashMap map = new HashMap();
        map.put("java",10);
        map.put("java",20);
        map.put("php",10);
        System.out.println("map = "+map);
//        源码的执行
/*
 1.执行HashMap构造器
 初始化加载因子0.75
HashMap$Node[] table = null
 2.执行put方法 调用方法执行key的hash值 (h = key.hashCode()) ^ (h >>> 16)
     public V put(K key, V value) {
        return putVal(hash(key), key, value, false, true);
    }
    3.执行putVal
        final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
                   boolean evict) {
        Node[] tab; Node p; int n, i; //辅助变量
        if ((tab = table) == null || (n = tab.length) == 0)
            n = (tab = resize()).length;
            //取出hash值所对应的table的索引位置Node，如果为null直接加入K-V，
        if ((p = tab[i = (n - 1) & hash]) == null)
            tab[i] = newNode(hash, key, value, null);
        else {
            Node e; K k;  //辅助变量
            //用于判断key的是否相同  hash相同外加equals的比较结果为真，或者节点当中的key的值与加入的key的值相同，就进行覆盖处理
            if (p.hash == hash &&
                ((k = p.key) == key || (key != null && key.equals(k))))
                e = p;
            else if (p instanceof TreeNode)  //如果当前的Node已经是红黑树了，那就按照红黑树的方式处理
                e = ((TreeNode)p).putTreeVal(this, tab, hash, key, value);
            else {
            //Node后面是链表，做如下处理
                for (int binCount = 0; ; ++binCount) {
                    if ((e = p.next) == null) {  //便利到末尾也没有找到相同的元素就直接将新的元素加到最末尾
                        p.next = newNode(hash, key, value, null);
                        //如果他的链表个数大于8那么就进行树化
                        if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
                            treeifyBin(tab, hash);
                        break;
                    }
                    //如果链表当中有相同的元素，就对原有的元素进行覆盖
                    if (e.hash == hash &&
                        ((k = e.key) == key || (key != null && key.equals(k))))
                        break;
                    p = e;
                }
            }
            if (e != null) { // existing mapping for key
                V oldValue = e.value;
                if (!onlyIfAbsent || oldValue == null)
                    e.value = value;  //替换key对应的value
                afterNodeAccess(e);
                return oldValue;
            }
        }
        ++modCount; //每增加一个Node就进行size++用来判断是否应该扩容
        if (++size > threshold)  //大于临界值就进行扩容
            resize();
        afterNodeInsertion(evict);
        return null;
    }
    4.树扩容的代码分析
        final void treeifyBin(Node[] tab, int hash) {
        int n, index; Node e;
        //如果tab为空，或者tab的长度小于64，那么就进行扩容，扩容是二倍扩容
        if (tab == null || (n = tab.length) < MIN_TREEIFY_CAPACITY)
            resize();
            //下面才是树化的代码，书化对应的是剪枝，当红黑树当中的元素小于8时，将红黑树变成链表。
        else if ((e = tab[index = (n - 1) & hash]) != null) {
            TreeNode hd = null, tl = null;
            do {
                TreeNode p = replacementTreeNode(e, null);
                if (tl == null)
                    hd = p;
                else {
                    p.prev = tl;
                    tl.next = p;
                }
                tl = p;
            } while ((e = e.next) != null);
            if ((tab[index] = hd) != null)
                hd.treeify(tab);
        }
    }
     */
    }
}



 判断元素是否相同，关键在于key属性的两方面的比较，一方面是equals的结果，一方面是hashcode的值。


HashMap树化和扩容


韩顺平Java自学笔记 集合_第24张图片


 代码


package com.map_;

import java.util.HashMap;

public class HashMapSource1 {
    public static void main(String[] args) {
        HashMap map = new HashMap();
        for (int i =0 ;i<=12;i++){
            map.put(new A(i),"hello");
        }

        System.out.println("map = "+map);
    }
}


class A{
    private int num;

    public A(int num) {
        this.num = num;
    }

    @Override
    public String toString() {
        return "A{" +
                "num=" + num +
                '}';
    }

    @Override
    //所有A对象的hashcode的值都一样
    public int hashCode() {
        return 100;
    }
}


因为hashcode的值都一样，所以都加到table的一个Node节点上面了，当链表的长度大于8的时候不会树化，而是会对table进行扩容，table默认初始化的值为16，直至table>64时，Node上面长度超过8的链表才会树化。


 table小于64


韩顺平Java自学笔记 集合_第25张图片


 链表未进行树化


 韩顺平Java自学笔记 集合_第26张图片


当table>64并且链表的长度>8的时候 Node变为了TreeNode


韩顺平Java自学笔记 集合_第27张图片


 table的的长度是有阈值的，最后会变成树


韩顺平Java自学笔记 集合_第28张图片


 对代码进行一些修改，不进行树化，单纯的看看如何扩容


package com.map_;

import java.util.HashMap;

public class HashMapSource1 {
    public static void main(String[] args) {
        HashMap map = new HashMap();
        for (int i =0 ;i<=12;i++){
//          基本类型数字的Node存放是比较均匀的，比引用类型均匀
            map.put(i,"hello");
        }
        map.put("aaaa","bbbb");

        System.out.println("map = "+map);
    }
}


class A{
    private int num;

    public A(int num) {
        this.num = num;
    }

    @Override
    public String toString() {
        return "A{" +
                "num=" + num +
                '}';
    }

    @Override
    //所有A对象的hashcode的值都一样
    public int hashCode() {
        return 100;
    }
}


结果仅进行table的扩容，没有进行树化


韩顺平Java自学笔记 集合_第29张图片


 Hashtable类的详解


Hashtable为什么不使用驼峰命名法，版本遗留问题，版本太早，当时没有强制要求使用驼峰命名法。


1.Hashtable的使用


韩顺平Java自学笔记 集合_第30张图片


 Hashtablede初始table大小为11,临界值依旧是table长度*0.75


package com.map_;

import java.util.Hashtable;

public class HashTable_ {
    public static void main(String[] args) {
        Hashtable hashTable = new Hashtable();
        hashTable.put("john",100);
        hashTable.put("lucy",100);
        hashTable.put("lic",100);
        hashTable.put("lic",88);
        hashTable.put("1",1);
        hashTable.put("2",1);
        hashTable.put("3",1);
        hashTable.put("4",1);
        hashTable.put("5",1);
        hashTable.put("6",1);
        hashTable.put("7",1);

        System.out.println(hashTable);
    }
}



扩容是原来的长度*2+1


源代码


韩顺平Java自学笔记 集合_第31张图片


 properties类


基本介绍


韩顺平Java自学笔记 集合_第32张图片


配置文件，用来修改程序当中的一些关键的属性，比如密码，用户名，方便修改。


读取配置文件https://www.cnblogs.com/xudong-bupt/p/3758136.html案例


package com.map_;

import java.util.Properties;

public class Properties_ {
    public static void main(String[] args) {
        Properties properties = new Properties();
        /*基本的使用方法*/
//        添加数据
//        教继承的是Has和Hashtable所以K和V都不能是null
        properties.put("join",1);
        properties.put("tom",2);
//        properties.put("abc",null);  会出现空指针异常
        properties.put("lucy",100);
//        当key相同的时候，会进行替换
        properties.put("lic",88);
        properties.put("lic",885);

        System.out.println(properties);
//        获取数据
        System.out.println(properties.get("lic"));
//        删除数据
        System.out.println(properties.remove("lic"));
        System.out.println(properties);
//        修改数据  使用相同的key就可以了
        properties.put("join",10);
        System.out.println(properties);
    }
}



 结果




{tom=2, lic=885, join=1, lucy=100}
 885
 885
 {tom=2, join=1, lucy=100}
 {tom=2, join=10, lucy=100}




实际开发当中集合的使用


1.选择是单列还是双列


是一组对象还是一组键值对




 如何理解集合的有序与无序icon-default.png?t=M7J4https://blog.csdn.net/chen_wwww/article/details/105402079


 TreeSet的使用


韩顺平Java自学笔记 集合_第33张图片


可以传入构造器


TreeSet的底层是TreeMap 


韩顺平Java自学笔记 集合_第34张图片


 代码


package com.map_;

import java.util.Comparator;
import java.util.TreeSet;

public class TreeSet_ {
    public static void main(String[] args) {
//        TreeSet treeSet = new TreeSet();
//        当我们使用的是无参构造器的时候，仍然是无序的，我们应该自定义他的比较方法，要使用到匿名的内部类，指定排序的规则
        TreeSet treeSet = new TreeSet(new Comparator() {
            @Override
            public int compare(Object o1, Object o2) {
//                调用String的比较方法，比较的是ascll吗的值
//                return ((String) o1).compareTo(((String) o2));
//                按照String的长度来进行排序
                return ((String)o1).length()-((String)o2).length();
            }
        });


        treeSet.add("jack");
        treeSet.add("韩顺平");
        treeSet.add("sp");
        treeSet.add("a");

        System.out.println(treeSet);
//      1.将将构造器比较对象，传给了TreeSet底层的TreeMap的this.Comparator属性
//      2.在进行元素添加的时候 ，会执行
        /*
        *
        if (cpr != null) {  //cpr是我们的匿名内部类的对象
            do {
                parent = t;
//                动态绑定到我们的匿名内部类
                cmp = cpr.compare(key, t.key);
                if (cmp < 0)
                    t = t.left;
                else if (cmp > 0)
                    t = t.right;
                else
//                对Value进行覆盖，如果两个值相等的话 TreeSet内部的数据结构是Tree
                   return t.setValue(value);
            } while (t != null);
        }
        * */
    }
}



代码结果




[a, sp, 韩顺平, jack]




TreeMap源代码解读


源码


package com.map_;

import java.util.Comparator;
import java.util.TreeMap;

public class TreeMap_ {
    public static void main(String[] args) {
//        默认的构造器也是无序的  有默认的比较器，看首字母的ascll值来进行排序
//        TreeMap treeMap = new TreeMap();
//        实现了比较器之后的方法
        TreeMap treeMap = new TreeMap(new Comparator() {
            @Override
            public int compare(Object o1, Object o2) {
//                按照字符串的ascll进行排序
//                return ((String)o1).compareTo(((String)o2));
//                按照字符串的长度来进行解析  相等长度的字符串会被替换 key没有被替换，但是Value被替换了
                return ((String)o1).length()-((String)o2).length();
            }
        });
        treeMap.put("jack","杰克");
        treeMap.put("tom","汤姆");
        treeMap.put("kristina","科儒斯缇娜");
        treeMap.put("smith","史密斯");

        System.out.println(treeMap);
        /*
        * 对于源码的解析
        * 1。构造器，传入comparator
        * 2,。调用put方法
        * 第一次添加  将K，V封装到Entry对象当中，放到root当中
        *         Entry t = root;
        *         if (t == null) {
            compare(key, key); // type (and possibly null) check
//用来检测放入的元素是否为null
            root = new Entry<>(key, value, null);
            size = 1;
            modCount++;
            return null;
        }
        * 2.以后添加
        *Comparator cpr = comparator;
        if (cpr != null) {
            do { //遍历所有的key
                parent = t;
                cmp = cpr.compare(key, t.key); //动态绑定匿名内部类
                if (cmp < 0)
                    t = t.left;
                else if (cmp > 0)
                    t = t.right;
                else
                    return t.setValue(value); //如果发现绑定的key和原有的key相同就不进行替换
            } while (t != null);
        }
        * */
    }
}



运行结果




{tom=汤姆, jack=杰克, smith=史密斯, kristina=科儒斯缇娜}




Collection工具类


工具类提供的方法一




代码


import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;

public class Collections_ {
    public static void main(String[] args) {
//        创建ArrayList集合进行测试
        ArrayList list = new ArrayList();
        list.add("smith");
        list.add("tom");
        list.add("king");
        list.add("milan");
        list.add("A");
        list.add("B");
        System.out.println(list);
//      使用reverse对list当中的数据进行反转
        Collections.reverse(list);
        System.out.println(list);
//      shuffle方法对数组进行随机的排序  每执行一次，进行一次数组的随机排序
//        Collections.shuffle(list);
//        System.out.println(list);
//      sort根据元素的自然顺序进行升序的排列  按照字符串的大小首字母(ASCLL表)来进行排序
        Collections.sort(list);
        System.out.println(list);
//        传入一个匿名的内部类，按照自己写得方法进行排序
        Collections.sort(list, new Comparator() {
            @Override
            public int compare(Object o1, Object o2) {
//                可以加入校验代码尽心排序
                if(o1 instanceof String);
//                根据字符串的长度进行排序
                return ((String)o1).length()-((String)o2).length();
            }
        });
//        长度相同的化吗，是根据Ascll进行排序的  因为允许重复  所以说长度想相同的不会被替换掉
        System.out.println(list);
//      swap(List,int i,int j)将List集合i处的元素和j(从零开始算起)处的元素进行交换    元素不存在：IndexOutOfBoundsException会出现索引越界异常
        Collections.swap(list,2,3);
        System.out.println(list);
    }
}



运行结果




[smith, tom, king, milan, A, B]
 [B, A, milan, king, tom, smith]
 [A, B, king, milan, smith, tom]
 [A, B, tom, king, milan, smith]
 [A, B, king, tom, milan, smith]




工具类提供的方法二


韩顺平Java自学笔记 集合_第35张图片


代码


package com.collection;

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;

public class Collections1_ {
    public static void main(String[] args) {
        //        创建ArrayList集合进行测试
        ArrayList list = new ArrayList();
        list.add("smith");
        list.add("tom");
        list.add("king");
        list.add("milan");
        list.add("milan");
        list.add("milan");
        list.add("A");
        list.add("B");
        list.add("z");
//        非int类型的字符串不能直接转化为int类型
//        max给定自然排序元素当中最大的元素
        System.out.println(list);

        System.out.println(Collections.max(list));
//        返回长度对大的，根据指定的方法来进行排序
        Object max = Collections.max(list, new Comparator() {
            @Override
            public int compare(Object o1, Object o2) {
                return ((String) o1).length() - ((String) o2).length();
            }
        });
//        当长度一样的话，返回的是首字母Ascll值最大的
        System.out.println(max);
//        min方法和max方法的使用方式都是一样的
//      frequency返回元素出现的次数
        int milan = Collections.frequency(list, "milan");
        System.out.println(milan);
//        copy方法，可以将一个集合复制到另一个集合当中 直接复制会有数组越界异常 一定要对数组进行初始化赋值  集合的大小不一样使用的copy方法不一样

        ArrayList list1 = new ArrayList();
        for(int i=0;i


运行结果




[smith, tom, king, milan, milan, milan, A, B, z]
 z
 smith
 3
 [smith, tom, king, milan, milan, milan, A, B, z]
 [smith, tom, king, 米莉安, 米莉安, 米莉安, A, B, z]




课后总结


本章难度较大，内容较多。多听几遍，写一下思维导图。


HomeWork课后作业


HomeWork01


要求


韩顺平Java自学笔记 集合_第36张图片


 代码


package com.homework;

import java.util.ArrayList;

public class HomeWork1 {
    public static void main(String[] args) {
        News news = new News("新冠确诊病例超千万，数百万印度教徒铺横河“圣浴”引起民众担忧");
        News news1 = new News("男子想起两个月前捕捉的鱼还在往兜里,捞起一看赶紧放生。");

        ArrayList list = new ArrayList();
        list.add(news);
        list.add(news1);

        int size = list.size();
        for (int a =size-1 ; a>=0;a--){
            News o = (News) list.get(a);

            System.out.println(processTitle(o.getTitle()));
        }

    }
    public static String processTitle(String title){
        if (title ==null){
            return "";
        }
        if (title.length()>15){
            return title.substring(0,15)+"....";
        }else {
            return title;
        }
    }
}

class News{
    private String content;
    private String title;

    public News(String title) {
        this.title = title;
    }

    public String getContent() {
        return content;
    }

    public void setContent(String content) {
        this.content = content;
    }

    public String getTitle() {
        return title;
    }

    public void setTitle(String title) {
        this.title = title;
    }

    @Override
    public String toString() {
        return "News{ title=" + title  +
                '}';
    }

}


运行结果




男子想起两个月前捕捉的鱼还在往....
 新冠确诊病例超千万，数百万印度....




HomeWork02


韩顺平Java自学笔记 集合_第37张图片


 


 代码


package com.homework;

import java.util.ArrayList;
import java.util.Iterator;

public class HomeWork2 {
    public static void main(String[] args) {
        ArrayList list = new ArrayList();
        Car car = new Car("宝马", 400000);
        Car car1 = new Car("宾利", 5000000);
//        使用add添加元素
        list.add(car);
        list.add(car1);
        System.out.println(list);
//     使用remove移除元素
        list.remove(car);
        System.out.println(list);
//        使用contains查看元素是否存在
        System.out.println(list.contains(car));
//        使用size获取元素的个数
        System.out.println(list.size());
//        使用isEmpty判断元素是否为空
        System.out.println(list.isEmpty());
//        使用clear进行清空
        list.clear();
        System.out.println(list);
//        创建一个新的数组
        ArrayList list1 = new ArrayList();
        list1.add(car);
        list1.add(car1);
//      使用addAll添加多个元素
        list.addAll(list1);
        System.out.println(list);
//        使用containsAll来查询多个元素是否存在
        System.out.println(list.containsAll(list1));
//        使用removeAll来移除多个元素
        list.removeAll(list1);
        System.out.println(list);
//      使用增强 for和 迭代器来进行遍历
        for (Object o : list1) {
            System.out.println(o);
        }

        Iterator iterator = list1.iterator();
        while (iterator.hasNext()){
            Object next = iterator.next();
            System.out.println(next);
        }
    }
}

class Car{
    private String name;
    private int price;

    public Car(String name, int price) {
        this.name = name;
        this.price = price;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public void setPrice(int price) {
        this.price = price;
    }

    public int getPrice() {
        return price;
    }

    @Override
    public String toString() {
        return "Car{" +
                "name='" + name + '\'' +
                ", price=" + price +
                '}';
    }
}



运行结果




[Car{name='宝马', price=400000}, Car{name='宾利', price=5000000}]
 [Car{name='宾利', price=5000000}]
 false
 1
 false
 []
 [Car{name='宝马', price=400000}, Car{name='宾利', price=5000000}]
 true
 []
 Car{name='宝马', price=400000}
 Car{name='宾利', price=5000000}
 Car{name='宝马', price=400000}
 Car{name='宾利', price=5000000}




HomeWork03


要求


韩顺平Java自学笔记 集合_第38张图片


代码 


package com.homework;

import java.util.*;

public class HomeWork03 {
    public static void main(String[] args) {
        Map map = new HashMap();
        map.put("jack",650);
        map.put("tom",1200);
        map.put("smith",2900);
//      回顾操作Map的基本方法
        map.put("jack",2600);
        System.out.println(map);
        Set set = map.keySet();
        for (Object o : set) {
            map.put(o,(Integer)map.get(o)+100);
        }
        System.out.println(map);
//      遍历 可以回顾Map的六种遍历方法和原理
        Set set1 = map.entrySet();
        Iterator iterator = set1.iterator();
        while (iterator.hasNext()) {
            Map.Entry next = (Map.Entry) iterator.next();
            System.out.println(next.getKey()+"-"+next.getValue());
        }
        System.out.println("==================");
        Collection values = map.values();
        for (Object value : values) {
            System.out.println("工资="+value);
        }
    }
}


运行结果




{tom=1200, smith=2900, jack=2600}
 {tom=1300, smith=3000, jack=2700}
 tom-1300
 smith-3000
 jack-2700
 工资=1300
 工资=3000
 工资=2700




HomeWork04


简答题


韩顺平Java自学笔记 集合_第39张图片


代码 


package com.homework;

import java.util.TreeSet;

public class HomeWork04 {
    public static void main(String[] args) {
        TreeSet treeSet = new TreeSet();
        treeSet.add("jack");
        treeSet.add("tom");
        treeSet.add("jsp");
        treeSet.add("king");
        treeSet.add("king");  //加入不了是因为字符串的compareTo方法比较的是内容

        System.out.println(treeSet);
    }
}


运行结果




[jack, jsp, king, tom]




HomeWork05


韩顺平Java自学笔记 集合_第40张图片


 什么是动态绑定icon-default.png?t=M7J4https://blog.csdn.net/weixin_42247720/article/details/80450238?ops_request_misc=%257B%2522request%255Fid%2522%253A%2522166245695516782388043141%2522%252C%2522scm%2522%253A%252220140713.130102334..%2522%257D&request_id=166245695516782388043141&biz_id=0&utm_medium=distribute.pc_search_result.none-task-blog-2~all~top_positive~default-1-80450238-null-null.142^v46^pc_rank_34_queryrelevant25&utm_term=%E5%8A%A8%E6%80%81%E7%BB%91%E5%AE%9A&spm=1018.2226.3001.4187


代码


package com.homework;

import java.util.TreeSet;

public class HomeWork05 {
    public static void main(String[] args) {
        TreeSet treeSet = new TreeSet();
        treeSet.add(new Person());
    }
}
//      不实现接口，会报类型转换异常，因为TreeSet的底层会进行接口类型转换
class Person implements Comparable {
    @Override
    public int compareTo(Object o) {
        return 0;
    }
}


HomeWork06


韩顺平Java自学笔记 集合_第41张图片


代码


package com.homework;

import java.util.HashSet;
import java.util.Objects;

public class HomeWork06 {
    public static void main(String[] args) {
//        前提是你重写了Hashcode方法
        HashSet hashSet = new HashSet();
        Person p1 = new Person(1001, "小王");
        Person p2 = new Person(1002, "小明");

        hashSet.add(p1);
        hashSet.add(p2);
//        只能在这里进行删除之后就删除不了p1了，删除p1会打歪
//        System.out.println(hashSet.remove(p1));

        p1.setName("小张");
//        显示删除失败，因为重写了hashcode方法，修改属性之后hashcode也就变了，寻找不到最开始的p1的位置了
        System.out.println(hashSet.remove(p1));
//        可以加进去，因为这个位置的hashcode是没有人站的，p1的hashcode虽然改变了，但是位置没有移动
        hashSet.add(new Person(1001, "小张"));
        System.out.println(hashSet);
//        也可以加进去，因为当进行对比遍历的会后，p1假冒的是小张，小王家住了小张。
//        对比是根据hash和equals对比的，p1当中的是小张，所以hashcode不一样，不会覆盖
        hashSet.add(new Person(1001, "小王"));
        System.out.println(hashSet);
//      再加就不行了，还是四个元素
        hashSet.add(new Person(1001, "小王"));
        System.out.println(hashSet);
//        现在remove小王是失败的 打的失小张家，因为p1冒充了小张。
        System.out.println(hashSet.remove(p1));
        System.out.println(hashSet);
    }
}

class Person{
    private int id;
    private String  name;

    public Person(int id, String  name) {
        this.id = id;
        this.name = name;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String  getName() {
        return name;
    }

    public void setName(String  name) {
        this.name = name;
    }

    @Override
    public boolean equals(Object object) {
        if (this == object) return true;
        if (object == null || getClass() != object.getClass()) return false;
        Person person = (Person) object;
        return id == person.id &&
                name == person.name;
    }
//  通过类当中的属性来计算hash
    @Override
    public int hashCode() {
        return Objects.hash(id, name);
    }

    @Override
    public String toString() {
        return "Person{" +
                "id=" + id +
                ", name=" + name +
                '}';
    }
}



 运行结果




false
 [Person{id=1001, name=小张}, Person{id=1001, name=小张}, Person{id=1002, name=小明}]
 [Person{id=1001, name=小张}, Person{id=1001, name=小张}, Person{id=1001, name=小王}, Person{id=1002, name=小明}]
 [Person{id=1001, name=小张}, Person{id=1001, name=小张}, Person{id=1001, name=小王}, Person{id=1002, name=小明}]
 true
 [Person{id=1001, name=小张}, Person{id=1001, name=小王}, Person{id=1002, name=小明}]




 HomeWork07


 韩顺平Java自学笔记 集合_第42张图片


 








最终总结，集合类之间的关系和使用环境还不太了解，多涉及。

























你可能感兴趣的:(java,servlet,jvm)






    

  • 华为OD机试 - 单向链表中间节点（Java & JS & Python & C & C++）
华为OD题库
华为od链表java

    须知哈喽，本题库完全免费，收费是为了防止被爬，大家订阅专栏后可以私信联系退款。感谢支持文章目录须知题目描述输出描述解析代码题目描述给定一个单链表L，请编写程序输出L中间结点保存的数据。如果有两个中间结点，则输出第二个中间结点保存的数据。例如：给定L为1→7→5，则输出应该为7；给定L为1→2→3→4，则输出应该为3；输入描述每个输入包含1个测试用例。每个测试用例：第一行给出链表首结点的地址、结点总
    

    • 

  • 学习JavaEE的日子 Day32 线程池
A 北枝
学习JavaEE学习java-eejava线程池

    Day32线程池1.引入一个线程完成一项任务所需时间为：创建线程时间-Time1线程中执行任务的时间-Time2销毁线程时间-Time32.为什么需要线程池(重要)线程池技术正是关注如何缩短或调整Time1和Time3的时间，从而提高程序的性能。项目中可以把Time1，T3分别安排在项目的启动和结束的时间段或者一些空闲的时间段线程池不仅调整Time1，Time3产生的时间段，而且它还显著减少了创建
    

    • 

  • 请简单介绍一下Shiro框架是什么？Shiro在Java安全领域的主要作用是什么？Shiro主要提供了哪些安全功能？
AaronWang94
shirojavajava安全开发语言

    请简单介绍一下Shiro框架是什么？Shiro框架是一个强大且灵活的开源安全框架，为Java应用程序提供了全面的安全解决方案。它主要用于身份验证、授权、加密和会话管理等功能，可以轻松地集成到任何JavaWeb应用程序中，并提供了易于理解和使用的API，使开发人员能够快速实现安全特性。Shiro的核心组件包括Subject、SecurityManager和Realms。Subject代表了当前与应用
    

    • 

  • 通俗易懂：什么是Java虚拟机（JVM）？它的主要作用是什么？
大龄下岗程序员
mysqljavamysqlspring

    Java虚拟机（JavaVirtualMachine,JVM）是一种软件实现的抽象计算机，它负责执行Java字节码（Bytecode）。Java程序并不是直接在物理计算机上运行，而是先由Java编译器将源代码编译成与平台无关的字节码，然后由JVM负责读取字节码并在实际硬件架构上运行。JVM的主要作用包括以下几个方面：1.跨平台性-JVM是Java语言“一次编写，到处运行”（WriteOnce,Ru
    

    • 

  • 3、JavaWeb-Ajax/Axios-前端工程化-Element
所谓远行Misnearch
#JavaWeb前端ajaxelementuijava前端框架

    P34Ajax介绍Ajax:AsynchroousJavaScriptAndXML，异步的JS和XMLJS网页动作，XML一种标记语言，存储数据，作用：数据交换：通过Ajax给服务器发送请求，并获取服务器响应的数据异步交互：在不重新加载整个页面的情况下，与服务器交换数据并实现更新部分网页的技术，例如：搜索联想、用户名是否可用的校验等等。同步与异步：同步：服务器在处理中客户端要处于等待状态，输入域名
    

    • 

  • 枚举使用笔记
万变不离其宗_8
项目笔记笔记

    1.java枚举怎么放在方法上面的注释里面/***保存*@paramuserId用户id*@paramtype见枚举{@linkcom.common.enums.TypeEnum}*@return*/voidsave(LonguserId,Stringtype);
    

    • 

  • Python dict字符串转json对象，小数精度丢失问题
朝如青丝 暮成雪
jsonpython

    一前言JSON(JavaScriptObjectNotation)是一种轻量级的数据交换格式，dict是Python的一种数据格式。本篇介绍一个float数据转换时精度丢失的案例。二问题描述importjsontest_str1='{"π":3.1415926535897932384626433832795028841971}'test_str2='{"value":10.00000}'print
    

    • 

  • java实体中返回前端的double类型四舍五入（格式化）
婲落ヽ紅顏誶
java

    根据业务，需要通过后端给前端返回部分double类型的数值，一般需要保留两位小数，使用jackson转换对象packagecom.ruoyi.common.core.config;importcom.fasterxml.jackson.core.JsonGenerator;importcom.fasterxml.jackson.databind.JsonSerializer;importcom.f
    

    • 

  • Java中HashMap底层数据结构及主要参数?
山间漫步人生路
java数据结构开发语言

    在Java中，HashMap的底层数据结构主要基于数组和链表，同时在Java8及以后的版本中，当链表长度超过一定阈值时，链表会转换为红黑树来优化性能。这种结构结合了数组和链表的优点，既提供了快速的随机访问，又允许动态地扩展存储桶的大小。HashMap的主要参数包括：初始容量（InitialCapacity）：这是HashMap在创建时设定的桶数组的大小。默认值为16。这个值可以根据预计存储的键值对
    

    • 

  • Java学习笔记01
.wsy.
日常java学习笔记

    1.1Java简介Java的前身是Oak，詹姆斯·高斯林是java之父。1.2Java体系Java是一种与平台无关的语言，其源代码可以被编译成一种结构中立的中间文件（.class，字节码文件）于Java虚拟机上运行。1.2.3专有名词JDK提供编译、运行Java程序所需要的种种工具及资源。JRE是运行Java所依赖的环境的集合。JVM是一个虚构出来的计算机，通过在实际的计算机上仿真模拟各种计算机功
    

    • 

  • Java回溯知识点（含面试大厂题和源码）
一成码农
java面试开发语言

    回溯算法是一种通过遍历所有可能的候选解来寻找所有解的算法，如果候选解被确认不是一个解（或至少不是最后一个解），回溯算法会通过在上一步进行一些变化来丢弃这个解，即“回溯”并尝试另一个候选解。回溯法通常用递归方法来实现，在解决排列、组合、选择问题时非常有效。回溯算法的核心要点：路径：也就是已经做出的选择。选择列表：也就是你当前可以做的选择。结束条件：也就是到达决策树底层，无法再做出选择的条件。回溯算法
    

    • 

  • Azkaban各种类型的Job编写
__元昊__

    一、概述原生的Azkaban支持的plugin类型有以下这些：command：Linuxshell命令行任务gobblin：通用数据采集工具hadoopJava：运行hadoopMR任务java：原生java任务hive：支持执行hiveSQLpig：pig脚本任务spark：spark任务hdfsToTeradata：把数据从hdfs导入TeradatateradataToHdfs：把数据从Te
    

    • 

  • java基础相关面试题详细总结
。。。。。96
java开发语言

    1.Java中的数据类型有哪些？答：Java中的数据类型包括基本数据类型（如整数、浮点数、字符等）和引用数据类型（如类、接口、数组等）。2.什么是面向对象编程（OOP）？答：面向对象编程是一种编程范式，它将数据和对数据的操作封装在一起，形成对象。通过对象之间的交互来实现程序的功能。3.解释类和对象的关系。答：类是对象的抽象描述，而对象是类的具体实例。一个类可以创建多个对象，每个对象都具有类中定义的
    

    • 

  • javascript 日期转换为时间戳，时间戳转换为日期的函数
cdcdhj
javascript学习日记javascript开发语言ecmascript

    日期转化为时间戳，主要用valueOf()来进行转化为毫秒时间戳，getTime()IOS系统无法解析转换，所以都有valueOf()letgetTimestampOrDate=function(timestamp){lettimeStamp='';constregex=/^\d{4}(-|\/)\d{2}(-|\/)\d{2}$/;constregex2=/^\d{4}(-|\/)\d{2}(-
    

    • 

  • Java面试题：解释JVM的内存结构，并描述堆、栈、方法区在内存结构中的角色和作用，Java中的多线程是如何实现的，Java垃圾回收机制的基本原理，并讨论常见的垃圾回收算法
杰哥在此
Java系列javajvm算法面试

    Java内存模型与多线程的深入探讨在Java的世界里，内存模型和多线程是开发者必须掌握的核心知识点。它们不仅关系到程序的性能和稳定性，还直接影响到系统的可扩展性和可靠性。下面，我将通过三个面试题，带领大家深入理解Java内存模型、多线程以及并发编程的相关原理和实践。面试题一：请解释JVM的内存结构，并描述堆、栈、方法区在内存结构中的角色和作用。关注点：JVM内存结构的基本组成堆、栈、方法区的功能和
    

    • 

  • COMP315 JavaScript Cloud Computing for E Commerce
zhuyu0206girl
javascript开发语言ecmascript

    Assignment1:Javascript1IntroductionAcommontaskincloudcomputingisdatacleaning,whichistheprocessoftakinganinitialdatasetthatmaycontainerroneousorincompletedata,andremovingorfixingthoseelementsbeforeform
    

    • 

  • JSON与AJAX：网页交互的利器
入冉心
jsonajax前端

    在现代Web开发中，JSON（JavaScriptObjectNotation）和AJAX（AsynchronousJavaScriptandXML）是两项不可或缺的技术。它们共同为网页提供了动态、实时的数据交互能力，为用户带来了更加流畅和丰富的体验。本文将详细介绍JSON和AJAX的概念、原理，并通过代码示例展示它们在实际开发中的应用。一、JSON：轻量级的数据交换格式JSON是一种轻量级的数据
    

    • 

  • 程序员开发技术整理
laizhixue
学习前端框架

    前端技术：vue-前端框架element-前端框架bootstrap-前端框架echarts-图标组件C#后端技术：webservice：soap架构：简单的通信协议，用于服务通信ORM框架：对象关系映射，如EF：对象实体模型，是ado.net中的应用技术soap服务通讯：xml通讯ado.net：OAuth2:登录授权认证：Token认证：JWT：jsonwebtokenJava后端技术：便捷工
    

    • 

  • javascript的数据类型及转换
田小田txt

    一、JavaScript数据类型：共有string，number，boolean，object，function五种数据类型；其中Object，Date，Array为对象型；2个不包含任何值的数据类型：null，undefined。二、Typeof查看数据类型：typeof"John"//返回stringtypeof3.14//返回numbertypeofNaN//返回numbertypeoffa
    

    • 

  • java线程之Lock的使用
dimdark

    目标:大致介绍一下java.util.concurrent.locks包下的类,接口及其常用方法1.Lock接口Lock接口使用Lock接口的最佳模式:publicvoidmethod()throwInterruptedException{try{lock.lock();//lock.lockUninterruptibly();}finally{lock.unlock();}}用户必须手动释放Lo
    

    • 

  • 第六届蓝桥杯大赛软件赛省赛Java 大学C组题解
爱跑步的程序员~
刷题蓝桥杯省赛

    文章目录A隔行变色思路解题方法复杂度CodeB立方尾不变思路解题方法复杂度CodeC无穷分数思路解题方法复杂度CodeD奇妙的数字思路解题方法复杂度CodeE移动距离思路解题方法复杂度CodeF垒骰子思路解题方法复杂度CodeA隔行变色思路这是一个简单的计数问题。我们需要找出21到50之间的奇数数量。奇数行将被染成蓝色，偶数行将被染成白色。解题方法我们可以使用一个for循环从21遍历到50，然后使
    

    • 

  • Java学习笔记04：Java_数组
JasonYangQ
Javajava

    文章目录1.数组1.1数组介绍1.2数组的定义格式1.2.1第一种格式1.2.2第二种格式1.3数组的动态初始化1.3.1什么是动态初始化1.3.2动态初始化格式1.3.3动态初始化格式详解1.4数组元素访问1.4.1什么是索引1.4.2访问数组元素格式1.4.3示例代码1.5内存分配1.5.1内存概述1.5.2java中的内存分配1.9数组的静态初始化1.9.1什么是静态初始化1.9.2静态初始
    

    • 

  • 【设计模式】Java 设计模式之桥接模式（Bridge）
新手村长
Java设计模式设计模式java桥接模式

    桥接模式（BridgePattern）是结构型设计模式的一种，它主要解决的是抽象部分与实现部分的解耦问题，使得两者可以独立变化。这种类型的设计模式属于结构型模式，因为该模式涉及如何组合接口和它们的实现。将抽象部分与实现部分分离，使它们都可以独立地变化。一、桥接模式概述桥接模式的主要思想是将抽象与实现进行解耦，使得二者可以独立进行变化。在桥接模式中，抽象部分和实现部分被分离出来，抽象部分定义了一个抽
    

    • 

  • Websocket服务监听收发消息
beiback
Java服务器问题websocket网络协议网络

    目录1.pom依赖坐标2.项目配置端口和项目包名2.创建处理器3.注册处理器4.前端页面1.pom依赖坐标org.springframework.bootspring-boot-starter-websocket2.项目配置端口和项目包名application.propertiesserver.port=8088//路径规范：为应用的所有servlet提供一个统一的前缀，使URL结构更加清晰和一致
    

    • 

  • Netty服务器结合WebSocke协议监听和接收数据
beiback
服务器问题Java服务器运维netty

    目录1.pom依赖2.配置属性3.创建netty服务器4.建立监听和响应5.创建启动器6.前端static下页面7.前端js8.注意异常问题9.创建netty服务器--使用守护线程1.pom依赖io.nettynetty-all4.1.86.Final2.配置属性application.properties#启动端口server.port=8088server.servlet.context-pa
    

    • 

  • 基于SSM+Vue企业销售培训系统 企业人才培训系统 企业课程培训管理系统 企业文化培训班系统Java
计算机程序老哥

    作者主页：计算机毕业设计老哥有问题可以主页问我一、开发介绍1.1开发环境开发语言：Java数据库：MySQL系统架构：B/S后端：SSM(Spring+SpringMVC+Mybatis)前端：Vue工具：IDEA或者Eclipse，JDK1.8，Maven二、系统介绍2.1图片展示注册登录页面：登陆.png前端页面功能：首页、培训班、在线学习、企业文化、交流论坛、试卷列表、系统公告、留言反馈、个
    

    • 

  • java selenium 元素点击不了
马达马达达
selenium测试工具

    最近做了一个页面爬取，很有意思被机缘巧合下解决了。这个元素很奇怪，用xpath可以定位元素，但是就是click()不了。试过了网上搜的一些办法：//尝试一WebElementa_tag=driver.findElement(By.xpath("xxx"));a_tag.click();//点击不了，卡住//尝试二WebDriverWaitwait=newWebDriverWait(driver,1
    

    • 

  • 【Java初阶（三）】方法的使用
PU-YUHAN
Java从入门到精通java开发语言递归方法

    ❣博主主页:33的博客❣▶文章专栏分类:Java从入门到精通◀我的代码仓库:33的代码仓库目录1.前言2.方法的概念2.1方法定义2.2实参和形参的关系3.方法的重载3.1方法重载的概念4.递归4.1递归的概念4.2递归过程分析4.3递归练习5.总结1.前言在前面的学习中，我们已经学习了Java的部分知识，包括数据类型与变量，运算符，分支与循环以及输入和输出这些基础知识，我们继续对Java的学习进
    

    • 

  • 解析XML文件的几种方式？
人生在勤，不索何获
xml

    在Java中解析XML文件可以通过多种方式完成，其中最常用的有DOM（DocumentObjectModel）、SAX（SimpleAPIforXML）和StAX（StreamingAPIforXML）。每种方式有其特点和适用场景。1.DOM解析DOM解析是一种将整个XML文档加载到内存中，构造成一个树形结构，然后你可以很方便地访问任何数据节点的方法。这种方法适用于需要频繁读写操作的场景。impo
    

    • 

  • javascript实现SM2加密解密
人生在勤，不索何获
javascript前端jquery

    前提JavaWeb环境前端代码window.sm2=function(t){functioni(e){if(r[e])returnr[e].exports;varn=r[e]={i:e,l:!1,exports:{}};returnt[e].call(n.exports,n,n.exports,i),n.l=!0,n.exports}varr={};returni.m=t,i.c=r,i.d=fu
    

    • 

  • Java实现的基于模板的网页结构化信息精准抽取组件：HtmlExtractor
yangshangchuan
信息抽取HtmlExtractor精准抽取信息采集

    HtmlExtractor是一个Java实现的基于模板的网页结构化信息精准抽取组件，本身并不包含爬虫功能，但可被爬虫或其他程序调用以便更精准地对网页结构化信息进行抽取。
 
HtmlExtractor是为大规模分布式环境设计的，采用主从架构，主节点负责维护抽取规则，从节点向主节点请求抽取规则，当抽取规则发生变化，主节点主动通知从节点，从而能实现抽取规则变化之后的实时动态生效。
如
    

    • 

  • java编程思想 -- 多态
百合不是茶
java多态详解

    一: 向上转型和向下转型
面向对象中的转型只会发生在有继承关系的子类和父类中（接口的实现也包括在这里）。父类：人    子类：男人向上转型： Person p = new Man() ; //向上转型不需要强制类型转化向下转型： Man man =
    

    • 

  • [自动数据处理]稳扎稳打,逐步形成自有ADP系统体系
comsci
dp

    
      对于国内的IT行业来讲,虽然我们已经有了"两弹一星",在局部领域形成了自己独有的技术特征,并初步摆脱了国外的控制...但是前面的路还很长....
      首先是我们的自动数据处理系统还无法处理很多高级工程...中等规模的拓扑分析系统也没有完成,更加复杂的
    

    • 

  • storm 自定义 日志文件
商人shang
stormclusterlogback

    Storm中的日志级级别默认为INFO，并且，日志文件是根据worker号来进行区分的，这样，同一个log文件中的信息不一定是一个业务的，这样就会有以下两个需求出现：
1. 想要进行一些调试信息的输出
2. 调试信息或者业务日志信息想要输出到一些固定的文件中
 
不要怕，不要烦恼，其实Storm已经提供了这样的支持，可以通过自定义logback 下的 cluster.xml 来输
    

    • 

  • Extjs3 SpringMVC使用 @RequestBody 标签问题记录
21jhf

    springMVC使用 @RequestBody(required = false) UserVO userInfo
传递json对象数据，往往会出现http 415，400,500等错误，总结一下需要使用ajax提交json数据才行，ajax提交使用proxy，参数为jsonData，不能为params；另外，需要设置Content-type属性为json，代码如下：
（由于使用了父类aaa
    

    • 

  • 一些排错方法
文强chu
方法

    1、java.lang.IllegalStateException: Class invariant violation
at org.apache.log4j.LogManager.getLoggerRepository(LogManager.java:199)at org.apache.log4j.LogManager.getLogger(LogManager.java:228)
at o
    

    • 

  • Swing中文件恢复我觉得很难
小桔子
swing

           我那个草了！老大怎么回事，怎么做项目评估的？只会说相信你可以做的，试一下，有的是时间！
       用java开发一个图文处理工具，类似word，任意位置插入、拖动、删除图片以及文本等。文本框、流程图等，数据保存数据库，其余可保存pdf格式。ok,姐姐千辛万苦，
    

    • 

  • php 文件操作
aichenglong
PHP读取文件写入文件

    1 写入文件
@$fp=fopen("$DOCUMENT_ROOT/order.txt", "ab");
if(!$fp){
echo "open file error" ;
exit;
}
$outputstring="date:"." \t tire:".$tire."
    

    • 

  • MySQL的btree索引和hash索引的区别
AILIKES
数据结构mysql算法

    Hash 索引结构的特殊性，其 检索效率非常高，索引的检索可以一次定位，不像B-Tree 索引需要从根节点到枝节点，最后才能访问到页节点这样多次的IO访问，所以 Hash 索引的查询效率要远高于 B-Tree 索引。    
可能很多人又有疑问了，既然 Hash 索引的效率要比 B-Tree 高很多，为什么大家不都用 Hash 索引而还要使用 B-Tree 索引呢
    

    • 

  • JAVA的抽象--- 接口 --实现
百合不是茶

    抽象 接口 实现接口
 
//抽象 类 ,方法
 
//定义一个公共抽象的类 ,并在类中定义一个抽象的方法体
抽象的定义使用abstract
 
abstract class A 定义一个抽象类 例如：
//定义一个基类
public abstract class A{
 
 
//抽象类不能用来实例化，只能用来继承
//
    

    • 

  • JS变量作用域实例
bijian1013
作用域

    <script>
var scope='hello';
function a(){
console.log(scope); //undefined
var scope='world';
console.log(scope); //world
console.log(b); 
    

    • 

  • TDD实践（二）
bijian1013
javaTDD

    实践题目：分解质因数
Step1：
单元测试：
package com.bijian.study.factor.test;
import java.util.Arrays;
import junit.framework.Assert;
import org.junit.Before;
import org.junit.Test;
import com.bijian.
    

    • 

  • [MongoDB学习笔记一]MongoDB主从复制
bit1129
mongodb

    MongoDB称为分布式数据库，主要原因是1.基于副本集的数据备份， 2.基于切片的数据扩容。副本集解决数据的读写性能问题，切片解决了MongoDB的数据扩容问题。
  事实上，MongoDB提供了主从复制和副本复制两种备份方式，在MongoDB的主从复制和副本复制集群环境中，只有一台作为主服务器，另外一台或者多台服务器作为从服务器。 本文介绍MongoDB的主从复制模式，需要指明
    

    • 

  • 【HBase五】Java API操作HBase
bit1129
hbase

    import java.io.IOException;
import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.hbase.HBaseConfiguration;
import org.apache.hadoop.hbase.HColumnDescriptor;
import org.apache.ha
    

    • 

  • python调用zabbix api接口实时展示数据
ronin47

    zabbix api接口来进行展示。经过思考之后，计划获取如下内容：     1、  获得认证密钥     2、  获取zabbix所有的主机组     3、  获取单个组下的所有主机     4、  获取某个主机下的所有监控项  
    

    • 

  • jsp取得绝对路径
byalias
绝对路径

    在JavaWeb开发中，常使用绝对路径的方式来引入JavaScript和CSS文件，这样可以避免因为目录变动导致引入文件找不到的情况，常用的做法如下：
一、使用${pageContext.request.contextPath}
　　代码” ${pageContext.request.contextPath}”的作用是取出部署的应用程序名，这样不管如何部署，所用路径都是正确的。

    

    • 

  • Java定时任务调度：用ExecutorService取代Timer
bylijinnan
java

    《Java并发编程实战》一书提到的用ExecutorService取代Java Timer有几个理由，我认为其中最重要的理由是：
如果TimerTask抛出未检查的异常，Timer将会产生无法预料的行为。Timer线程并不捕获异常，所以 TimerTask抛出的未检查的异常会终止timer线程。这种情况下，Timer也不会再重新恢复线程的执行了;它错误的认为整个Timer都被取消了。此时，已经被
    

    • 

  • SQL 优化原则
chicony
sql

    
一、问题的提出
　在应用系统开发初期，由于开发数据库数据比较少，对于查询SQL语句，复杂视图的的编写等体会不出SQL语句各种写法的性能优劣，但是如果将应用系统提交实际应用后，随着数据库中数据的增加，系统的响应速度就成为目前系统需要解决的最主要的问题之一。系统优化中一个很重要的方面就是SQL语句的优化。对于海量数据，劣质SQL语句和优质SQL语句之间的速度差别可以达到上百倍，可见对于一个系统
    

    • 

  • java 线程弹球小游戏
CrazyMizzz
java游戏

    最近java学到线程，于是做了一个线程弹球的小游戏，不过还没完善
这里是提纲
1.线程弹球游戏实现
1.实现界面需要使用哪些API类
JFrame
JPanel
JButton
FlowLayout
Graphics2D
Thread
Color
ActionListener
ActionEvent
MouseListener
Mouse
    

    • 

  • hadoop jps出现process information unavailable提示解决办法
daizj
hadoopjps

    hadoop jps出现process information unavailable提示解决办法  
jps时出现如下信息：
3019 -- process information unavailable3053 -- process information unavailable2985 -- process information unavailable2917 -- 
    

    • 

  • PHP图片水印缩放类实现
dcj3sjt126com
PHP

    
<?php
class Image{
private $path;
function __construct($path='./'){
$this->path=rtrim($path,'/').'/';
}
//水印函数，参数：背景图，水印图，位置，前缀,TMD透明度
public function water($b,$l,$pos
    

    • 

  • IOS控件学习：UILabel常用属性与用法
dcj3sjt126com
iosUILabel

    参考网站：
http://shijue.me/show_text/521c396a8ddf876566000007
http://www.tuicool.com/articles/zquENb
http://blog.csdn.net/a451493485/article/details/9454695
http://wiki.eoe.cn/page/iOS_pptl_artile_281
    

    • 

  • 完全手动建立maven骨架
eksliang
javaeclipseWeb

    建一个 JAVA 项目 ：
mvn archetype:create
-DgroupId=com.demo
-DartifactId=App
[-Dversion=0.0.1-SNAPSHOT]
[-Dpackaging=jar]
建一个 web 项目 ：
mvn archetype:create
-DgroupId=com.demo
-DartifactId=web-a
    

    • 

  • 配置清单
gengzg
配置

    1、修改grub启动的内核版本
vi /boot/grub/grub.conf
将default 0改为1
拷贝mt7601Usta.ko到/lib文件夹
拷贝RT2870STA.dat到 /etc/Wireless/RT2870STA/文件夹
拷贝wifiscan到bin文件夹，chmod 775 /bin/wifiscan
拷贝wifiget.sh到bin文件夹，chm
    

    • 

  • Windows端口被占用处理方法
huqiji
windows

    以下文章主要以80端口号为例，如果想知道其他的端口号也可以使用该方法..........................1、在windows下如何查看80端口占用情况?是被哪个进程占用?如何终止等.        这里主要是用到windows下的DOS工具,点击"开始"--"运行",输入&
    

    • 

  • 开源ckplayer 网页播放器， 跨平台(html5, mobile)，flv, f4v, mp4, rtmp协议. webm, ogg, m3u8 ！
天梯梦
mobile

    CKplayer，其全称为超酷flv播放器，它是一款用于网页上播放视频的软件，支持的格式有：http协议上的flv,f4v,mp4格式，同时支持rtmp视频流格 式播放，此播放器的特点在于用户可以自己定义播放器的风格，诸如播放/暂停按钮，静音按钮，全屏按钮都是以外部图片接口形式调用，用户根据自己的需要制作 出播放器风格所需要使用的各个按钮图片然后替换掉原始风格里相应的图片就可以制作出自己的风格了，
    

    • 

  • 简单工厂设计模式
hm4123660
java工厂设计模式简单工厂模式

           简单工厂模式（Simple Factory Pattern）属于类的创新型模式，又叫静态工厂方法模式。是通过专门定义一个类来负责创建其他类的实例，被创建的实例通常都具有共同的父类。简单工厂模式是由一个工厂对象决定创建出哪一种产品类的实例。简单工厂模式是工厂模式家族中最简单实用的模式，可以理解为是不同工厂模式的一个特殊实现。 
    

    • 

  • maven笔记
zhb8015
maven

    跳过测试阶段：
mvn package -DskipTests
临时性跳过测试代码的编译：
mvn package -Dmaven.test.skip=true
 
maven.test.skip同时控制maven-compiler-plugin和maven-surefire-plugin两个插件的行为，即跳过编译，又跳过测试。
 
指定测试类
mvn test
    

    • 

  • 非mapreduce生成Hfile，然后导入hbase当中
Stark_Summer
maphbasereduceHfilepath实例

    最近一个群友的boss让研究hbase，让hbase的入库速度达到5w+/s，这可愁死了，4台个人电脑组成的集群，多线程入库调了好久，速度也才1w左右，都没有达到理想的那种速度，然后就想到了这种方式，但是网上多是用mapreduce来实现入库，而现在的需求是实时入库，不生成文件了，所以就只能自己用代码实现了，但是网上查了很多资料都没有查到，最后在一个网友的指引下，看了源码，最后找到了生成Hfile
    

    • 

  • jsp web tomcat 编码问题
王新春
tomcatjsppageEncode

    今天配置jsp项目在tomcat上，windows上正常，而linux上显示乱码，最后定位原因为tomcat 的server.xml 文件的配置，添加 URIEncoding 属性：
<Connector port="8080" protocol="HTTP/1.1"
connectionTi
    

    •