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

韩顺平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)

        

            

                
    
                    
  • Long类型前后端数据不一致
                        igotyback
前端
                        
    响应给前端的数据浏览器控制台中response中看到的Long类型的数据是正常的到前端数据不一致前后端数据类型不匹配是一个常见问题，尤其是当后端使用Java的Long类型（64位）与前端JavaScript的Number类型（最大安全整数为2^53-1，即16位）进行数据交互时，很容易出现精度丢失的问题。这是因为JavaScript中的Number类型无法安全地表示超过16位的整数。为了解决这个问
    
                    
    • 
                    
  • LocalDateTime 转 String
                        igotyback
java开发语言
                        
    importjava.time.LocalDateTime;importjava.time.format.DateTimeFormatter;publicclassMain{publicstaticvoidmain(String[]args){//获取当前时间LocalDateTimenow=LocalDateTime.now();//定义日期格式化器DateTimeFormatterformat
    
                    
    • 
                    
  • Linux下QT开发的动态库界面弹出操作（SDL2）
                        13jjyao
QT类qt开发语言sdl2linux
                        
    需求：操作系统为linux，开发框架为qt，做成需带界面的qt动态库，调用方为java等非qt程序难点：调用方为java等非qt程序，也就是说调用方肯定不带QApplication::exec()，缺少了这个，QTimer等事件和QT创建的窗口将不能弹出(包括opencv也是不能弹出)；这与qt调用本身qt库是有本质的区别的思路：1.调用方缺QApplication::exec()，那么我们在接口
    
                    
    • 
                    
  • DIV+CSS+JavaScript技术制作网页（旅游主题网页设计与制作）云南大理
                        STU学生网页设计
网页设计期末网页作业html静态网页html5期末大作业网页设计web大作业
                        
    ️精彩专栏推荐作者主页:【进入主页—获取更多源码】web前端期末大作业：【HTML5网页期末作业(1000套)】程序员有趣的告白方式：【HTML七夕情人节表白网页制作(110套)】文章目录二、网站介绍三、网站效果▶️1.视频演示2.图片演示四、网站代码HTML结构代码CSS样式代码五、更多源码二、网站介绍网站布局方面：计划采用目前主流的、能兼容各大主流浏览器、显示效果稳定的浮动网页布局结构。网站程
    
                    
    • 
                    
  • 【华为OD机试真题2023B卷 JAVA&JS】We Are A Team
                        若博豆
java算法华为javascript
                        
    华为OD2023（B卷）机试题库全覆盖，刷题指南点这里WeAreATeam时间限制：1秒|内存限制：32768K|语言限制：不限题目描述：总共有n个人在机房，每个人有一个标号（1<=标号<=n），他们分成了多个团队，需要你根据收到的m条消息判定指定的两个人是否在一个团队中，具体的：1、消息构成为：abc，整数a、b分别代
    
                    
    • 
                    
  • 关于城市旅游的HTML网页设计——(旅游风景云南 5页)HTML+CSS+JavaScript
                        二挡起步
web前端期末大作业javascripthtmlcss旅游风景
                        
    ⛵源码获取文末联系✈Web前端开发技术描述网页设计题材，DIV+CSS布局制作,HTML+CSS网页设计期末课程大作业|游景点介绍|旅游风景区|家乡介绍|等网站的设计与制作|HTML期末大学生网页设计作业，Web大学生网页HTML：结构CSS：样式在操作方面上运用了html5和css3，采用了div+css结构、表单、超链接、浮动、绝对定位、相对定位、字体样式、引用视频等基础知识JavaScrip
    
                    
    • 
                    
  • HTML网页设计制作大作业（div+css） 云南我的家乡旅游景点 带文字滚动
                        二挡起步
web前端期末大作业web设计网页规划与设计htmlcssjavascriptdreamweaver前端
                        
    Web前端开发技术描述网页设计题材，DIV+CSS布局制作,HTML+CSS网页设计期末课程大作业游景点介绍|旅游风景区|家乡介绍|等网站的设计与制作HTML期末大学生网页设计作业HTML：结构CSS：样式在操作方面上运用了html5和css3，采用了div+css结构、表单、超链接、浮动、绝对定位、相对定位、字体样式、引用视频等基础知识JavaScript：做与用户的交互行为文章目录前端学习路线
    
                    
    • 
                    
  • node.js学习
                        小猿L
node.jsnode.js学习vim
                        
    node.js学习实操及笔记温故node.js，node.js学习实操过程及笔记~node.js学习视频node.js官网node.js中文网实操笔记githubcsdn笔记为什么学node.js可以让别人访问我们编写的网页为后续的框架学习打下基础，三大框架vuereactangular离不开node.jsnode.js是什么官网：node.js是一个开源的、跨平台的运行JavaScript的运行
    
                    
    • 
                    
  • Java 重写(Override)与重载(Overload)
                        叨唧唧的

                        
    Java重写(Override)与重载(Overload)重写(Override)重写是子类对父类的允许访问的方法的实现过程进行重新编写,返回值和形参都不能改变。即外壳不变，核心重写！重写的好处在于子类可以根据需要，定义特定于自己的行为。也就是说子类能够根据需要实现父类的方法。重写方法不能抛出新的检查异常或者比被重写方法申明更加宽泛的异常。例如：父类的一个方法申明了一个检查异常IOExceptio
    
                    
    • 
                    
  • 简单了解 JVM
                        记得开心一点啊
jvm
                        
    目录♫什么是JVM♫JVM的运行流程♫JVM运行时数据区♪虚拟机栈♪本地方法栈♪堆♪程序计数器♪方法区/元数据区♫类加载的过程♫双亲委派模型♫垃圾回收机制♫什么是JVMJVM是JavaVirtualMachine的简称，意为Java虚拟机。虚拟机是指通过软件模拟的具有完整硬件功能的、运行在一个完全隔离的环境中的完整计算机系统（如：JVM、VMwave、VirtualBox）。JVM和其他两个虚拟机
    
                    
    • 
                    
  • 1分钟解决 -bash: mvn: command not found，在Centos 7中安装Maven
                        Energet!c
开发语言
                        
    1分钟解决-bash:mvn:commandnotfound，在Centos7中安装Maven检查Java环境1下载Maven2解压Maven3配置环境变量4验证安装5常见问题与注意事项6总结检查Java环境Maven依赖Java环境，请确保系统已经安装了Java并配置了环境变量。可以通过以下命令检查：java-version如果未安装，请先安装Java。1下载Maven从官网下载：前往Apach
    
                    
    • 
                    
  • Java企业面试题3
                        马龙强_
java
                        
    1.break和continue的作用(智*图)break：用于完全退出一个循环（如for,while）或一个switch语句。当在循环体内遇到break语句时，程序会立即跳出当前循环体，继续执行循环之后的代码。continue：用于跳过当前循环体中剩余的部分，并开始下一次循环。如果是在for循环中使用continue，则会直接进行条件判断以决定是否执行下一轮循环。2.if分支语句和switch分
    
                    
    • 
                    
  • JVM、JRE和 JDK：理解Java开发的三大核心组件
                        Y雨何时停T
Javajava
                        
    Java是一门跨平台的编程语言，它的成功离不开背后强大的运行环境与开发工具的支持。在Java的生态中，JVM（Java虚拟机）、JRE（Java运行时环境）和JDK（Java开发工具包）是三个至关重要的核心组件。本文将探讨JVM、JDK和JRE的区别，帮助你更好地理解Java的运行机制。1.JVM：Java虚拟机（JavaVirtualMachine）什么是JVM？JVM，即Java虚拟机，是Ja
    
                    
    • 
                    
  • Java面试题精选：消息队列(二)
                        芒果不是芒
Java面试题精选javakafka
                        
    一、Kafka的特性1.消息持久化：消息存储在磁盘，所以消息不会丢失2.高吞吐量：可以轻松实现单机百万级别的并发3.扩展性：扩展性强，还是动态扩展4.多客户端支持：支持多种语言（Java、C、C++、GO、）5.KafkaStreams（一个天生的流处理）:在双十一或者销售大屏就会用到这种流处理。使用KafkaStreams可以快速的把销售额统计出来6.安全机制：Kafka进行生产或者消费的时候会
    
                    
    • 
                    
  • 白骑士的Java教学基础篇 2.5 控制流语句
                        白骑士所长
Java教学java开发语言
                        
    欢迎继续学习Java编程的基础篇！在前面的章节中，我们了解了Java的变量、数据类型和运算符。接下来，我们将探讨Java中的控制流语句。控制流语句用于控制程序的执行顺序，使我们能够根据特定条件执行不同的代码块，或重复执行某段代码。这是编写复杂程序的基础。通过学习这一节内容，你将掌握如何使用条件语句和循环语句来编写更加灵活和高效的代码。条件语句条件语句用于根据条件的真假来执行不同的代码块。if语句‘
    
                    
    • 
                    
  • python语法——三目运算符
                        HappyRocking
pythonpython三目运算符
                        
    在java中，有三目运算符，如：intc=(a>b)?a:b表示c取两者中的较大值。但是在python，不能直接这样使用，估计是因为冒号在python有分行的关键作用。那么在python中，如何实现类似功能呢？可以使用ifelse语句，也是一行可以完成，格式为：aifbelsec表示如果b为True，则表达式等于a，否则等于c。如：c=(aif(a>b)elseb)同样是完成了取最大值的功能。
    
                    
    • 
                    
  • ArrayList 源码解析
                        程序猿进阶
Java基础ArrayListListjava面试性能优化架构设计idea
                        
    ArrayList是Java集合框架中的一个动态数组实现，提供了可变大小的数组功能。它继承自AbstractList并实现了List接口，是顺序容器，即元素存放的数据与放进去的顺序相同，允许放入null元素，底层通过数组实现。除该类未实现同步外，其余跟Vector大致相同。每个ArrayList都有一个容量capacity，表示底层数组的实际大小，容器内存储元素的个数不能多于当前容量。当向容器中添
    
                    
    • 
                    
  • Java爬虫框架（一）--架构设计
                        狼图腾-狼之传说
java框架java任务html解析器存储电子商务
                        
    一、架构图那里搜网络爬虫框架主要针对电子商务网站进行数据爬取，分析，存储，索引。爬虫：爬虫负责爬取，解析，处理电子商务网站的网页的内容数据库：存储商品信息索引：商品的全文搜索索引Task队列：需要爬取的网页列表Visited表：已经爬取过的网页列表爬虫监控平台：web平台可以启动，停止爬虫，管理爬虫，task队列，visited表。二、爬虫1.流程1)Scheduler启动爬虫器，TaskMast
    
                    
    • 
                    
  • Java：爬虫框架
                        dingcho
Javajava爬虫
                        
    一、ApacheNutch2【参考地址】Nutch是一个开源Java实现的搜索引擎。它提供了我们运行自己的搜索引擎所需的全部工具。包括全文搜索和Web爬虫。Nutch致力于让每个人能很容易,同时花费很少就可以配置世界一流的Web搜索引擎.为了完成这一宏伟的目标,Nutch必须能够做到:每个月取几十亿网页为这些网页维护一个索引对索引文件进行每秒上千次的搜索提供高质量的搜索结果简单来说Nutch支持分
    
                    
    • 
                    
  • python怎么将png转为tif_png转tif
                        weixin_39977276

                        
    发国外的文章要求图片是tif，cmyk色彩空间的。大小尺寸还有要求。比如网上大神多，找到了一段代码，感谢！https://www.jianshu.com/p/ec2af4311f56https://github.com/KevinZc007/image2Tifimportjava.awt.image.BufferedImage;importjava.io.File;importjava.io.Fi
    
                    
    • 
                    
  • JavaScript 中，深拷贝（Deep Copy）和浅拷贝（Shallow Copy）
                        跳房子的前端
前端面试javascript开发语言ecmascript
                        
    在JavaScript中，深拷贝（DeepCopy）和浅拷贝（ShallowCopy）是用于复制对象或数组的两种不同方法。了解它们的区别和应用场景对于避免潜在的bugs和高效地处理数据非常重要。以下是对深拷贝和浅拷贝的详细解释，包括它们的概念、用途、优缺点以及实现方式。1.浅拷贝（ShallowCopy）概念定义：浅拷贝是指创建一个新的对象或数组，其中包含了原对象或数组的基本数据类型的值和对引用数
    
                    
    • 
                    
  • JAVA·一个简单的登录窗口
                        MortalTom
java开发语言学习
                        
    文章目录概要整体架构流程技术名词解释技术细节资源概要JavaSwing是Java基础类库的一部分，主要用于开发图形用户界面（GUI）程序整体架构流程新建项目，导入sql.jar包（链接放在了文末），编译项目并运行技术名词解释一、特点丰富的组件提供了多种可视化组件，如按钮（JButton）、文本框（JTextField）、标签（JLabel）、下拉列表（JComboBox）等，可以满足不同的界面设计
    
                    
    • 
                    
  • WebMagic：强大的Java爬虫框架解析与实战
                        Aaron_945
Javajava爬虫开发语言
                        
    文章目录引言官网链接WebMagic原理概述基础使用1.添加依赖2.编写PageProcessor高级使用1.自定义Pipeline2.分布式抓取优点结论引言在大数据时代，网络爬虫作为数据收集的重要工具，扮演着不可或缺的角色。Java作为一门广泛使用的编程语言，在爬虫开发领域也有其独特的优势。WebMagic是一个开源的Java爬虫框架，它提供了简单灵活的API，支持多线程、分布式抓取，以及丰富的
    
                    
    • 
                    
  • 博客网站制作教程
                        2401_85194651
javamaven
                        
    首先就是技术框架：后端：Java+SpringBoot数据库：MySQL前端：Vue.js数据库连接：JPA(JavaPersistenceAPI)1.项目结构blog-app/├──backend/│├──src/main/java/com/example/blogapp/││├──BlogApplication.java││├──config/│││└──DatabaseConfig.java
    
                    
    • 
                    
  • 00. 这里整理了最全的爬虫框架（Java + Python）
                        有一只柴犬
爬虫系列爬虫javapython
                        
    目录1、前言2、什么是网络爬虫3、常见的爬虫框架3.1、java框架3.1.1、WebMagic3.1.2、Jsoup3.1.3、HttpClient3.1.4、Crawler4j3.1.5、HtmlUnit3.1.6、Selenium3.2、Python框架3.2.1、Scrapy3.2.2、BeautifulSoup+Requests3.2.3、Selenium3.2.4、PyQuery3.2
    
                    
    • 
                    
  • 深入浅出 -- 系统架构之负载均衡Nginx的性能优化
                        xiaoli8748_软件开发
系统架构系统架构负载均衡nginx
                        
    一、Nginx性能优化到这里文章的篇幅较长了，最后再来聊一下关于Nginx的性能优化，主要就简单说说收益最高的几个优化项，在这块就不再展开叙述了，毕竟影响性能都有多方面原因导致的，比如网络、服务器硬件、操作系统、后端服务、程序自身、数据库服务等，对于性能调优比较感兴趣的可以参考之前《JVM性能调优》中的调优思想。优化一：打开长连接配置通常Nginx作为代理服务，负责分发客户端的请求，那么建议开启H
    
                    
    • 
                    
  • 常见的 JVM 调优方法有哪些？
                        爪哇天下
jvm
                        
    常见的JVM调优方法有哪些？可以具体到调整哪个参数，调成什么值？对年轻代的EdenSurvivor的比例进行配置-XX:SurvivorRatio=8：表示设置2个Survivor区：1个Eden区的大小比值为2:8，这意味着Survivor区占整个年轻代的1/5，这个参数默认为8如果经常性的SurvivorTo放不下YGC的剩余的对象时候，可以适当的调整比例常用的CMS收集器：设置回收阈值，需要
    
                    
    • 
                    
  • JAVA学习笔记之23种设计模式学习
                        victorfreedom
Java技术设计模式androidjava常用设计模式
                        
    博主最近买了《设计模式》这本书来学习，无奈这本书是以C++语言为基础进行说明，整个学习流程下来效率不是很高，虽然有的设计模式通俗易懂，但感觉还是没有充分的掌握了所有的设计模式。于是博主百度了一番，发现有大神写过了这方面的问题，于是博主迅速拿来学习。一、设计模式的分类总体来说设计模式分为三大类：创建型模式，共五种：工厂方法模式、抽象工厂模式、单例模式、建造者模式、原型模式。结构型模式，共七种：适配器
    
                    
    • 
                    
  • JavaScript `Map` 和 `WeakMap`详细解释
                        跳房子的前端
JavaScript原生方法javascript前端开发语言
                        
    在JavaScript中，Map和WeakMap都是用于存储键值对的数据结构，但它们有一些关键的不同之处。MapMap是一种可以存储任意类型的键值对的集合。它保持了键值对的插入顺序，并且可以通过键快速查找对应的值。Map提供了一些非常有用的方法和属性来操作这些数据对：set(key,value):将一个键值对添加到Map中。如果键已经存在，则更新其对应的值。get(key):获取指定键的值。如果键
    
                    
    • 
                    
  • 切换淘宝最新npm镜像源是
                        hai40587
npm前端node.js
                        
    切换淘宝最新npm镜像源是一个相对简单的过程，但首先需要明确当前淘宝npm镜像源的状态和最新的镜像地址。由于网络环境和服务更新，镜像源的具体地址可能会发生变化，因此，我将基于当前可获取的信息，提供一个通用的切换步骤，并附上最新的镜像地址（截至回答时）。一、了解npm镜像源npm（NodePackageManager）是JavaScript的包管理器，用于安装、更新和管理项目依赖。由于npm官方仓库
    
                    
    • 
                                
  • 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
    
                                
    •