noodles226
noodles226

java学习总结-集合（collection）

  本人正在学习java基础知识,非常感恩能够看到毕向东老师的java视频,他引领了我去思考问题,而不是生硬的去记一些知识点,下面是我对集合学习的总结和思考。

01-常用对象API(集合框架-概述).avi

问题1：什么是集合框架？

首先要理解集合这个词，它有另一个更加形象的名词：容器，所谓容器就是装载事物的器皿，而在java中最大的特征就是面向对象，所以可以推断出其实它就是用来装载对象的，便于我们去遍历和处理这些对象，关于框架的含义，其实就是它不是一个单独对象，而是有很多对象，并且相互存在区别和关系。

下图是目前集合的框架图，其中实线是具体的实现类，而虚线是接口或者工具类。

java学习总结-集合（collection）_第1张图片

                                                                 集合框架图

这里要说明的是，原来集合并没有怎么庞大的“家族”，在jdk的api中查看，jdk1.0的时候只有两个类即：Vector和Hashtable，因为后期发展，他们已经不能满足需要，所以2.0以后出现以上的框架图，而主要的优化就是容器丰富了和更加高效。就好比我们以前煮东西只需要一个大铁锅，但是因为后面物质和需求的发展，必须进行精细化，出现更加针对性的炊具。至于它们的优点和区别后面总结。

问题2：java有许多可以装载其它数据的“容器”，比如类、字符串缓冲池等，尤其是数组，不仅可以装载基本数据类型，也可以装载对象，跟我们要学习的集合存在某种程度的冲突，那么他们的区别在哪里？

数组的长度是固定，而集合的长度是可变的，数组一旦初始化以后，它所能装载的对象个数是不能超出它的长度的，而集合创建以后，可以任意的装载对象；具备的现实意义就是，大多数我们的数据是动态的，比如论坛网站的会员信息，门户网站的新闻，社交网站的状态，所以无法在程序中指定一个固定长度数值去装载它，只能要这里的集合去装载。

02-常用对象API(集合框架-体系&共性功能).avi

         整个集合框架的学习必须参考上面的集合框架图，首先需要的介绍是Collection，为什么呢？如果你仔细查看上图会发现，它下面有很多分支（向上的尖头指向它），而这正是java继承的特点，就是事物不断向上抽取共性（实际就是指方法），一般顶层都是接口，它包含了子类的共性方法。而我们发现其实集合框架顶层其实只有Collection、Map和Iterator，而Iterator其实不是容器，这一块后面具体介绍，所以首先我们要了解顶层接口有那些共性的方法，然后在去看看不同子类有那些特殊的方法。

         而容器从字面来说，它会具备的方法，无非添加、修改、删除、取出等主要功能，翻看API中java.util.Collection的方法：

1、 添加

boolean add(E e);

E可以理解为Object，其它是element（元素）的缩写。

boolean addAll(Colllection c);

是泛型，后面介绍。

2、 删除

boolean remove(Object o);

boolean removeAll(Collection c);

void clear();

移除collection中所有元素。

3、 取出

int size();

Iterator iterator();

           迭代器。

4、 判断

boolean isEmpty();

           容器中不包含元素,返回true。

boolean contains(object o);

boolean containsAll(Collection c);

           如果此collection 包含指定 collection 中的所有元素，则返回true。

retainAll(Collection c);

 仅保留此 collection 中那些也包含在指定collection 的元素（可选操作）,其实就是数学中的取交集。

03-常用对象API(集合框架-方法演示_1).avi

                   对上面介绍的collection方法的进行演示，我们需要寻找它的一个子类，这里就用ArrayList来演示。

import java.util.*;
 
class CollectionDemo {
        
         publicstatic void main(String[] args){
                   //创建容器1
                   ArrayListcoll = new ArrayList();
 
                   method1(coll);
                  
                   //创建容器2
                   ArrayListcoll2 = new ArrayList();
                  
                   method2(coll2);
                  
                   //创建容器2
                   ArrayListcoll3 = new ArrayList();
                  
                   method3(coll2,coll3);
                  
         }
        
         publicstatic void method1(Collection coll){
                  
                   //添加 字符串
                   coll.add("abc");
                   coll.add("123");
                   coll.add("efg");
                   //打印容器
                   System.out.println("size:"+coll.size()+","+coll);
                  
                   //包含
                   System.out.println(coll.contains("123"));
                  
                   //删除
                   coll.remove("123");
 
                   System.out.println("size:"+coll.size()+","+coll);
                  
                   //清除
                   coll.clear();
                   System.out.println("isEmpty:"+coll.isEmpty()+","+coll);
                   System.out.println("============method1=================");
                  
         }
         publicstatic void method2(Collection coll){
                  
                   coll.add(newPerson("zhangsan",23));
                   coll.add(newPerson("xiaoming",24));
                   coll.add(newPerson("lisi",25));      
                   coll.add(newPerson("wangwu",26));              
                  
                   System.out.println(coll);
                   //输出集合中每一个元素的字符串表现形式，即调用toString();
                  
                   //包含
                   System.out.println(coll.contains(newPerson("lisi",25)));
                   System.out.println(coll.contains("123"));
                   //删除
                   coll.remove(newPerson("lisi",25));
                   //打印
                   System.out.println(coll);
                   System.out.println("============method2=================");
         }
        
         publicstatic void method3(Collection coll,Collectioncoll2){
                  
                   coll2.add(newPerson("zhangsan",23));
                   coll2.add(newPerson("xiaoming",24)); 
                   //包含-容器
                   System.out.println(coll.containsAll(coll2));
                   //删除
                   //coll.removeAll(coll2);
                   //System.out.println(coll);
                   //合集
                   coll.retainAll(coll2);
                   System.out.println(coll);
                  
                  
                   System.out.println("============method3=================");
 
         }
}
 
class Person {
         privateString name;
         privateint age;
        
         Person(Stringname,int age){
                   this.name= name;
                   this.age= age;
         }
        
         publicString toString(){
                   returnname +":"+ age;
         }
        
         publicboolean equals(Object obj) throws ClassCastException{
                   if(!(obj instanceof Person))
                            thrownew ClassCastException("不是Person类");
                   Personp = (Person)obj;
                   returnname.equals(p.name) && age == p.age;
         }
}


注意：在contains和remove方法使用的时候，这里面包含了判断元素是否相等的前提，其实它是调用元素的equals方法，而我们自定义的类是从Object类中继承过来，它比较对象的地址，一般需要根据我们实际情况进行复写。

05-常用对象API(集合框架-迭代器使用).avi

1、 什么是迭代器？

可以看着获取容器中元素的方法。

2、 迭代器的获取？

Collection中调用iterator()方法。

import java.util.*;
 
class IteratorDemo {
         publicstatic void main(String[] args){
                   ArrayListcoll = new ArrayList();
                  
                   coll.add(newPerson("李四",23));
                   coll.add(newPerson("王五",24));
                   coll.add(newPerson("张三",22));
                  
                   Iteratorit = coll.iterator();
                   while(it.hasNext()){
                            System.out.println(it.next());
                   }
                   System.out.println("===================================");
                   for(Iteratorit2 = coll.iterator();it2.hasNext();){
                            System.out.println(it2.next());
                   }
         }
}

06-常用对象API(集合框架-迭代器的原理).avi

1、 为什么要使用迭代器？

集合框架中包含List、Set分支，List下面有（ArrayList、LinkedList），Set下面有（HashSet、TreeSet、LinkedHashSet），它们是不同的容器，最本质的区别就是数据结构不同，即在内存中存放数据的规则不一样。这导致的一个问题，不同容器获取数据的方法是不一样的，比如AarryList是顺序的，可以按角标获取元素get(int index)，而set是无序的，不能根据角标去获取元素;在容器使用上是非常不方便的，这时候就需要考虑建立一个统一方法解决这个问题，这就是迭代器的由来。

 

2、 迭代器的原理？

首先建立统一的方法供调用，实现方式就是让Collection继承了一个Iterable接口，该接口包含iterator()方法，返回一个Iterator<T>接口，这样需要在Collection子类中实现iterator()方法，而实现这个方法最关键的是返回一个Iterator对象，应该怎么做：通过内部类继承Iterator接口，复写它的hasNext()和next()方法，分别表示“如果仍有元素可以迭代，则返回 true”、“返回迭代的下一个元素。”而怎么实现这两个方法，需要根据自身的数据结构。

 

07-常用对象API(集合框架-List和Set的特点).avi

                   List：有序，元素可以重复的，元素都有角标。

                   Set:  无序，元素不可以重复。

08-常用对象API(集合框架-List集合的常见方法).avi

                   最重要的就是元素含有角标，所以可以按角标进行添加、删除、修改和获取。

 

1、  添加

void add(intindex, E element);

在列表的指定位置插入指定元素

                   voidadd(int index,Collection c);

 将指定 collection 中的所有元素都插入到列表中的指定位置

2、  删除

E remove(intindex);

         移除列表中指定位置的元素。注意：方法返回被移除的元素。

3、  修改

E set(intindex,E element);

         用指定元素替换列表中指定位置的元素；注意：返回替换前的元素。

4、  获取

E get(intindex);

         返回列表中指定位置的元素。

intIndexOf(Object o);

         返回此列表中第一次出现该指定元素的索引；如果此列表不包含该元素，则返回-1.

intlastIndexof(Object o);

         返回比列表中最后出现该指定元素的索引；如果列表中不包含此元素，则返回-1.

ListsubList(int fromIndex,int toIndex);

         返回列表中指定的fromIndex和toIndex之间的部分视图。 

importjava.util.*;
 
class ListDemo {
        
         public static void main(String[] args){
                   ArrayList coll= new ArrayList();
                  
                   coll.add(new Person("王大",18));
                   coll.add(new Person("张三",20));
                   coll.add(new Person("王五",22));
                   coll.add(new Person("张三",20));
                   System.out.println(coll);
                  
                   //添加
                   coll.add(1,new Person("李二",19));
                   System.out.println(coll);
                  
                   //删除
                   System.out.println(coll.remove(1));
                   System.out.println(coll);
                  
                   //修改
                   System.out.println(coll.set(0,newPerson("李大",17)));//返回替换前的元素
                   System.out.println(coll);
                  
                   //获取
                   for(int i = 0; i

09-常用对象API(集合框架-ListIterator接口).avi

import java.util.*;
 
class ListIteratorDemo {
    
     public static voidmain(String[] args){
              ArrayListcoll = new ArrayList();
             
              coll.add(newPerson("王大",18));
              coll.add(newPerson("张三",20));
              coll.add(newPerson("王五",22));
    
              Iteratorit = coll.iterator();
              while(it.hasNext()){
                       Person p= it.next();
                       if(p.age== 20){
                                 coll.add(newPerson("小明",23));
                       }
                       System.out.println(p);
              }
     }
}

 如果在迭代器迭代的过程，集合操作列表元素，因为并发操作元素，这是会出现异常“ConcurrentModificationException”，这是需要Iterator的子接口ListIterator，该迭代器可以操作元素，只有List集合有。

import java.util.*;
 
class ListIteratorDemo {
    
     public static voidmain(String[] args){
              ArrayListcoll = new ArrayList();
             
              coll.add(newPerson("王大",18));
              coll.add(newPerson("张三",20));
              coll.add(newPerson("王五",22));
    
              ListIteratorit = coll.listIterator();
              while(it.hasNext()){
                       Person p= it.next();
                       if(p.age== 20){
                                 it.add(newPerson("小明",23));
                       }
                       System.out.println(p);
              }
     }
}

10-常用对象API(集合框架-List常用子类的特点).avi

         List常用子类：

                   --Vector:数组接口，查询慢，增删慢，因为同步。

                   --ArrayList：数组结构，查询快，增删慢，非同步。

                   --LinkedList：链表结合，增删快，查询慢，非同步。

11-常用对象API(集合框架-数组和链表).avi

链表

java学习总结-集合（collection）_第2张图片

而链表的区间不连续，查询数据时，索引的时间比数组会长。但是如上图所示，增删是比数组快，因为数值增删需要整体位移。

 

12-常用对象API(集合框架-Vector集合).avi

         Vector是jdk1.0是推出的集合容器，在2.0以后即被其它容器取代，不做介绍。 

13-常用对象API(集合框架-LinkedList集合).avi

         LinkedList在使用上具有差异性：链表存在头和尾，所谓含有特有的方法可以对链表头和尾的元素进行操作。

1、  添加。

void addFirst(E e);

           将指定元素插入此列表的开头。

void addLast(E e);

           将指定元素添加到此列表的结尾。

boolean offer(E e);

           将指定元素添加到此列表的末尾。

boolean offerFirst(E e);

           在此列表的开头插入指定的元素。

boolean offerLast(E e);

           在此列表的末尾插入指定元素。

两者的区别：在使用双端队列且有容量限制的时候，offer方法在遇到容量过小时，返回false,而add则抛出异常，建议使用offer。

2、  修改

E removeFirst();

           移除并返回此列表的第一个元素。    

E removeLast();

移除并返回此列表的最后一个元素。

 

3、  获取

E getFirst();

返回此列表的第一个元素。

E getLast();       

返回此列表的最后一个元素。

                  

 E peek();

       获取但不移除此列表的头。

 E peekFrist();

       获取但不移除此列表的第一个元素；如果此列表为空，则返回null。

 E peekLast();

        获取但不移除此列表的最后一个元素；如果此列表为空，则返回null。

 

E poll();

      获取并移除此列表的头。

E pollFrist();

        获取并移除此列表的第一个元素；如果此列表为空，则返回 null。

E pollLast();

      获取并移除此列表的最后一个元素；如果此列表为空，则返回 null。     

与remove的区别：当双端队列为空时remove抛出移除，而poll返回null。

           

14-常用对象API(集合框架-LinkedList集合-练习(堆栈和队列)).avi

import java.util.*;
 
class LinkedListDemo {
        
         publicstatic void main(String[] args){
                  
                   DuiLieduiLie = new DuiLie();
                   duiLie.add("123");
                   duiLie.add("456");           
                   duiLie.add("789");  
                  
                  System.out.println(duiLie.size());
 
                  
                   for(inti = 0;i < duiLie.size(); i++){
                            System.out.println(duiLie.get(i));
                   }
                  
                  
                   DuiZhanduiZhan= new DuiZhan();
                   duiZhan.add("123");
                   duiZhan.add("456");                 
                   duiZhan.add("789");       
                  
                   System.out.println(duiZhan.size());
 
                  
                   for(inti = 0;i < duiZhan.size(); i++){
                            System.out.println(duiZhan.get(i));
                   }
         }
}
 
class DuiLie {
        
         privateLinkedList coll ;
         DuiLie(){
                   coll= new LinkedList();
         }
         publicvoid add(T obj){
                   coll.add(obj);
         }
        
         publicT get(int index){
                   returncoll.get(index);
         }
        
         publicint size(){
                   returncoll.size();
         }
}
 
class DuiZhan {
        
         privateLinkedList coll ;
         DuiZhan(){
                   coll= new LinkedList();
         }
         publicvoid add(T obj){
                   coll.addFirst(obj);
         }
        
         publicT get(int index){
                   returncoll.get(index);
         }
        
         publicint size(){
                   returncoll.size();
         }
}

15-常用对象API(集合框架-ArrayList集合存储自定对象).avi

         上面已经介绍，需要注意的是在涉及到元素比较的方法，如contains、indexOf、retainAll、remove(Oject obj)时，默认调用的是元素的equals方法。


16-常用对象API(集合框架-HashSet集合).avi

         Set特点：无序，且不能重复的。

1、 Set集合怎么保证内部的元素是不重复的？

HashSet:首先比较元素的Hash码，即调用元素的hashCode()方法，如果不相同则元素不同；如果相同，则还需比较元素是否相同，即调用equals()方法，如果相同，则元素相同，不能装载，反之可以。

LinkedHashSet:同上。

TreeSet:调用元素的compareTo()方法或者是集合实现Comparator接口（优先compareTo()方法）。

2、  Set集合子类都有哪些？它们之间有什么区别？

--HashSet：无序，不重复。

--LinkedHashSet:有序，获取元素的顺序和存入一致。

--TreeSet:加载后的元素可以排序。

17-常用对象API(集合框架-哈希表_1).avi

    哈希表是一种算法，HashSet集合就是按hashCode返回的结果去存储和查询数据。比如我们去查找数元素时，首先拿到元素的hashCode值，然后去查找此hashcode对应的内存。

18-常用对象API(集合框架-哈希表_2).avi

1、 为什么在jdk关于equlas方法的介绍时，建议equals相同时，hashcode也要相同？

因为部分集合HashSet、HashMap在添加元素时，调用equals的前提就是HashCode相同，如果equals()相同，反回来说明元素的HashCode一定是相同的。因为equals相同，而HashCode不同，存在的问题就是相同元素会添加到HashSet、HashMap中。

其实真正判读是否相同的依据还是equlas，只是从设计上来说，部分集合的逻辑是需要判断HashCode来存储数据的。

19-常用对象API(集合框架-HashSet存储自定义对象).avi

import java.util.*;
 
 
class HashSetDemo {
         publicstatic void main(String[] args){
                   HashSetcoll = new HashSet();
                  
                   coll.add(newPerson("小强",25));                    
                   coll.add(newPerson("小明",23));
                   coll.add(newPerson("小张",24));  
                   coll.add(newPerson("小张",24));                    
        
 
                   for(Iteratorit = coll.iterator();it.hasNext();){
                            System.out.println(it.next());
                   }
         }
}
 
class Person {
         Stringname;
         intage;
        
         Person(Stringname,int age){
                   this.name= name;
                   this.age= age;
         }
        
         publicString toString(){
                   returnname +":"+ age;
         }
        
         publicboolean equals(Object obj) {
                   if(!(obj instanceof Person))
                            thrownew ClassCastException("不是Person类");
                   Personp = (Person)obj;
                   returnname.equals(p.name) && age == p.age;
         }
        
         publicint hashCode(){
                   returnname.hashCode()+31*age;
         }
}


20-常用对象API(集合框架练习).avi

 

21-常用对象API(集合框架-LinkedHashSet集合).avi

         特点：有序，hashSet的子类，就好像在hashSet基础上用一个链子根据元素存入的先后串联起来。

import java.util.*;
 
class LinkedHashSetDemo {
         publicstatic void main(String[] args){
                   //HashSeths = new HashSet();
                  
                   LinkedHashSeths = new LinkedHashSet();
                  
                   hs.add("xixi");                   
                   hs.add("hehe");
                   hs.add("haha");      
                   hs.add("88");                    
        
 
                   for(Iteratorit = hs.iterator();it.hasNext();){
                            System.out.println(it.next());
                   }
         }
}

22-常用对象API(集合框架-TreeSet集合).avi

         特点：可以按照元素排序。

1、 TreeSet是怎么实现元素排序的？

有两种方式：

第一种，元素需要实现comparable接口，复写compareTo方法，该方法比较两个元素，返回值为int，如果大于1，则顺序；等于0表示相等；小于0，则倒序。这又叫元素的自然排序。

importjava.util.*;
 
classTreeSetDemo {
public static void main(String[] args){
          
           TreeSet ts = newTreeSet();
          
           ts.add(new Person("小强",25));                       
           ts.add(new Person("小明",23));
           ts.add(new Person("小张",24));    
           ts.add(new Person("小李",23));                       
          
 
           for(Iterator it =ts.iterator();it.hasNext();){
                    System.out.println(it.next());
           }
}
}
 
classPerson implements Comparable{
String name;
int age;
Person(String name,int age){
           this.name = name;
           this.age = age;
}
public String toString(){
           return name +":"+ age;
}
public boolean equals(Object obj){
           if (!(obj instanceof Person))
                    throw newClassCastException("不是Person类");
           Person p = (Person)obj;
           return name.equals(p.name) &&age == p.age;
}
public int hashCode(){
           return name.hashCode()+31*age;
}
public int compareTo(Object obj){
           /*
           if (obj.getClass() != Person){
                    throws newClassCastException("类型错误");
           }
           */
          
           //健壮性判断
           if (!(obj instanceof Person))
                    throw newClassCastException("不是Person类");
          
           Person p = (Person)obj;
           //return age - ((Person)obj).age;
           int temp = this.age - p.age;
           return temp == 0?this.name.compareTo(p.name):temp;
}
}

第二种，是集合实现Comparator接口，实现compare()方法，传入两个元素，比较大小，规则如上。

importjava.util.*;
 
classTreeSetDemo {
public static void main(String[] args){
          
           TreeSet ts = newTreeSet(new MyComparator());
          
           ts.add(new Person("小强",25));                       
           ts.add(new Person("小明",23));
           ts.add(new Person("小张",24));    
           ts.add(new Person("小李",23));                       
          
 
           for(Iterator it =ts.iterator();it.hasNext();){
                    System.out.println(it.next());
           }
}
}
 
classPerson {
String name;
int age;
Person(String name,int age){
           this.name = name;
           this.age = age;
}
public String toString(){
           return name +":"+ age;
}
public boolean equals(Object obj){
           if (!(obj instanceof Person))
                    throw newClassCastException("不是Person类");
           Person p = (Person)obj;
           return name.equals(p.name) &&age == p.age;
}
public int hashCode(){
           return name.hashCode()+31*age;
}
}
 
classMyComparator implements Comparator {
public int compare(Person o1,Person o2){
           int temp = o1.age -o2.age;
           return temp == 0?  o1.name.compareTo(o2.name) : temp;
}
}


24-常用对象API(集合框架-TreeSet集合-二叉树).avi

25-常用对象API(集合框架-TreeSet集合练习-字符串长度排序).avi

         要点：集合自身的比较性优先于元素的比较性。    

import java.util.*;
 
class TreeSetTest {
         publicstatic void main(String[] args){
                  
                   TreeSetts = new TreeSet(new ComparatorByLength());
                  
                   ts.add("abc");                   
                   ts.add("adcdef");
                   ts.add("ac");   
                   ts.add("abcd");                          
                  
        
 
                   for(Iteratorit = ts.iterator();it.hasNext();){
                            System.out.println(it.next());
                   }
         }
}
 
class ComparatorByLength implementsComparator {
         publicint compare(String o1,String o2){
                   returno1.length() - o2.length();
         }
}
 
import java.util.*;
 
class TreeSetTest {
         publicstatic void main(String[] args){
                  
                   TreeSetts = new TreeSet(new ComparatorByLength());
                  
                   ts.add("abc");                   
                   ts.add("adcdef");
                   ts.add("ac");   
                   ts.add("ab");                     
                   ts.add("abcd");                          
                  
        
 
                   for(Iteratorit = ts.iterator();it.hasNext();){
                            System.out.println(it.next());
                   }
         }
}
 
class ComparatorByLength implementsComparator {
         publicint compare(Object o1,Object o2){
                   Strings1 = (String)o1;
                   Strings2 = (String)o2;
                   inttemp = s1.length() - s2.length();
                   returntemp == 0? s1.compareTo(s2) : temp;
         }
}
  
  
01-常用对象API(集合框架-Map集合特点&常用方法).avi
 
  
1、 Map集合的特点，与colllection的区别？
 
  
Map集合一次可以添加一对元素；collection一次添加一个元素。
 
  
Map称为双列集合；collection称为单列集合。
 
  
Map集合存放的是键值对，它们是映射关系，不能包含重复的键，一个键最多映射到一个值。
 
  
2、 有哪些常用方法？
 
  
1、 添加
 
  
V put(K key,V value);
 
  
           返回前一个和key关联的值，如果没有则为null。
 
  
2、 删除
 
  
void clear();
 
  
           清空Map集合。
 
  
V remove(K key)；
 
  
           根据键删除集合中的键值对。
 
  
3、 修改
 
  
4、 获取
 
  
V get(K key);    
 
  
         通过键获取值，如果没有该键，则返回null。
 
  
it size();
 
  
         获取键值对的个数。
 
  
 
 
  
5、 判断
 
  
boolean containsKey(k key);
 
  
         集合中是否包含该键。
 
  
boolean containsValue(V value);
 
  
         集合中是否包含该值。
 
  
boolean isEmpty();
 
  
         集合是否为空。

 
  
02-常用对象API(集合框架-常用方法演示).avi
 
  
 
  
import java.util.*;
 
class MapDemo {
        
         public static voidmain(String[] args){
                   //创建容器
                   HashMaphm = new HashMap();
                  
                   //添加
                   hm.put(1,"abc");
                   hm.put(3,"efg");
                   hm.put(2,"hij");
                   hm.put(4,"小李");           
                  
                   System.out.println(hm);
                  
                   System.out.println(hm.put(2,"小明"));
                  
                   System.out.println(hm);
                  
                   //删除
                   hm.remove(4);
                   System.out.println(hm);          
                  
                   //判断
                   System.out.println(hm.containsKey(2));
                   System.out.println(hm.containsKey(4));
                   System.out.println(hm.containsValue("abd"));      
                   System.out.println(hm.containsValue("abc"));
                   System.out.println(hm.containsValue(hm.isEmpty()));           
                  
                   //获取
                   System.out.println(hm.size());
                   System.out.println(hm.get(1));
                   System.out.println(hm.get(4));                
         }
}
 
 
  
03-常用对象API(集合框架-重点方法keySet演示图解).avi
 
  
1、 keySet()方法的介绍和使用？
 
  
Set keyset();
 
  
返回此映射中所包含的键的Set视图。
 
  
 
 
  
获取到Set集合，然后通过迭代器的next()方法获取到每一个键值，再通过Map的get(K key)方法，根据每一个键获取到值。
 
  
 
  
import java.util.*;
 
class KeySetDemo {
         publicstatic void main(String[] args) {
                   //创建容器
                   HashMaphm = new HashMap();
                  
                   //添加
                   hm.put(1,"abc");
                   hm.put(3,"efg");
                   hm.put(2,"hij");
                   hm.put(4,"小李");
                  
                   //调用keySet()返回set集合
                   Setset = hm.keySet();
                  
                   //调用迭代器，遍历Set元素
                   for(Iteratorit = set.iterator();it.hasNext();){
                            Integerkey = it.next();
                            //通过Map的get(key)方法，再获取到值
                            Stringvalue = hm.get(key);
                            System.out.println(key+":"+value);
                   }
         }
}
 
 
  
04-常用对象API(集合框架-重点方法entrySet演示图解).avi
 
  
1、 entrySet()方法的介绍，与keySet()方法的区别？
 
  
Set>entrySet();
 
  
                   返回此映射所包含的映射关系的set视图。
 
  
与keySet()的区别：它返回的也是Set集合，但是集合中包含的元素却不是
 
  
由Map的key值组成，它是Map中key和value的映射关系，它是一个明确类型，类名为Map.Entry，可以看出它是Map内部类，可以通过Set的迭代器来获取，在迭代过程中，它自身的方法可以获取key（getKey()）和value(getValue()),也可以修改value值(setValue())。
 
  
 
 
  
Jdk中关于Map.Entry的说明：映射项（键-值对）。Map.entrySet 方法返回映射的 collection 视图，其中的元素属于此类。获得映射项引用的唯一 方法是通过此 collection 视图的迭代器来实现。这些 Map.Entry 对象仅 在迭代期间有效；更确切地讲，如果在迭代器返回项之后修改了底层映射，则某些映射项的行为是不确定的，除了通过 setValue 在映射项上执行操作之外。
 
  
 
  
import java.util.*;
 
class EntrySetDemo {
          public static voidmain(String[] args) {
                   //创建容器
                   HashMaphm = new HashMap();
                  
                   //添加
                   hm.put(1,"abc");
                   hm.put(3,"efg");
                   hm.put(2,"hij");
                   hm.put(4,"小李");
                  
                   //调用keySet()返回set集合
                   Set>set = hm.entrySet();
                  
                  
                  
                   //调用迭代器，遍历Set元素
                   for(Iterator>it = set.iterator();it.hasNext();){
                            Map.Entryentry = it.next();
                           
                            Integerkey = entry.getKey();
                           
                            //修改
                            if(key==2)
                                      //hm.put(5,"++++++");迭代过程中集合不能操作元素
                                      entry.setValue("=======");
         
                            System.out.println(key+":"+entry.getValue());
                   }
          }
}
 
  

 
  
05-常用对象API(集合框架-方法values演示).avi
 
  
1、 values()方法介绍？
 
  
Collection values()；
 
  
                   返回此映射所包含的值的Collection视图。
 
  
它可以看做是keySet()对应的方法；keySet()返回的是key值的集合，因为Map中key值不能重复，所以返回的是Set集合；而values()返回的是Map中value值的集合，因为value可以重复，所以返回集合为Collection;而entrySet()返回的是两者的关系。
 
  
 
 
  
 
  
import java.util.*;
 
class ValuesDemo {
          public static voidmain(String[] args) {
                   //创建容器
                   HashMaphm = new HashMap();
                  
                   //添加
                   hm.put(1,"abc");
                   hm.put(3,"efg");
                   hm.put(2,"hij");
                   hm.put(4,"小李");
                  
                   //调用valuest()返回Collection集合
                   Collectionvalues = hm.values();
                  
                  
                  
                   //调用迭代器，遍历Collection元素
                   for(Iteratorit = values.iterator();it.hasNext();){
         
                            System.out.println(it.next());
                   }
          }
}
 
  
 
  
06-常用对象API(集合框架-Map集合-常见子类对象).avi
 
  
1、 Map的常见子类对象及特点？
 
  
--HashTable：jdk1.0推出，内部结构哈希表，同步的，不允许null作为键，null作为值。
 
  
                   --Properties:用来存储键值对型配置文件的信息，可以和IO技术相集合。
 
  
--HashMap:内部结构是哈希表，不是同步的，允许null作为键，null作为值。
 
  
--TreeMap:内部结构是二叉树，不是同步的。
 
  
--LinkedHashMap：内部结构是链表，不是同步的。
 
  
不同Map容器在实际应用中，最大的区别就是可以对键值对不同的处理，比如HashMap会对键做是否相同的判断，即判断hashCode和equlas，和HashSet相同。
 
  
 
 
  
07-常用对象API(集合框架-Map集合-HashMap存储自定义对象).avi
 
  
特点：HashMap会对键做是否相同的判断，即判断hashCode和equlas，和HashSet相同。
 
  
 
  
importjava.util.*;
 
classHashMapDemo {
        public static void main(String[] main){
                  //创建容器，存放个人信息和所属城市
                  HashMaphm = new HashMap();
                 
                  //添加
                  hm.put(new Person("小明",23),"上海");
                  hm.put(new Person("小李",22),"江苏");
                  hm.put(new Person("老王",44),"北京");       
                  hm.put(new Person("小强",32),"浙江");       
                  //修改
                  hm.put(new Person("小强",32),"海南");
 
                  //调用entrySet()返回set集合
                  Set>entrySet = hm.entrySet();
                 
                  //set迭代器
                  for(Iterator>it = entrySet.iterator();it.hasNext();){
                           //获取set中元素
                           Map.Entryentry = it.next();
                           //获取key值
                           Person key =entry.getKey();
                           //获取value值
                           String value =entry.getValue();
                          
                           System.out.println(key.name+":"+key.age+",地址:"+value);
                  }
        }
}
 
class Person {
        String name;
        int age;
       
        Person(String name,int age){
                  this.name = name;
                  this.age = age;
        }
       
        public String toString(){
                  return name +":"+age;
        }
       
        public boolean equals(Object obj){
                  if (!(obj instanceof Person))
                           throw newClassCastException("错误类型");
                  Person p = (Person)obj;
                  return name.equals(p.name)&& age == p.age;
        }
       
        public int hashCode(){
                  return name.hashCode()+31*age;
        }
}
 
  

 
  
08-常用对象API(集合框架-Map集合-TreeMap存储自定义对象).avi
 
  
特点：TreeMap会对键做大小判断，即元素中compareTo()方法的结果或者是TreeMap中Comparator接口compare()方法的结果，TreeMap相同。
 
  
 
 
  
 
  
import java.util.*;
 
class TreeMapDemo {
        public static voidmain(String[] main){
                  //创建容器，存放个人信息和所属城市
                  TreeMaptm = new TreeMap(new MyComparator());
                 
                  //添加
                  tm.put(newPerson("小明",23),"上海");
                  tm.put(newPerson("小李",22),"江苏");
                  tm.put(newPerson("老王",44),"北京");       
                  tm.put(newPerson("小强",32),"浙江");       
                  tm.put(newPerson("小强",19),"北京");                          
 
                  //调用entrySet()返回set集合
                  Set>entrySet = tm.entrySet();
                 
                  //set迭代器
                  for(Iterator>it = entrySet.iterator();it.hasNext();){
                           //获取set中元素
                           Map.Entryentry = it.next();
                           //获取key值
                           Personkey = entry.getKey();
                           //获取value值
                           Stringvalue = entry.getValue();
                          
                           System.out.println(key.name+":"+key.age+",地址:"+value);
                  }
        }
}
 
class MyComparator implements Comparator {
        public intcompare(Person o1,Person o2){
                  int temp =o1.age -o2.age;
                  return temp== 0?  o1.name.compareTo(o2.name) : temp;
        }
}
 
  
 
  
 
  
09-常用对象API(集合框架-Map集合-LinkedHashMap&关联源码).avi
 
  
特点：有序，获取键值对的顺序和添加顺序一致。
 
  
 
  
import java.util.*;
 
class LinkedHashMapDemo {
        public static voidmain(String[] main){
                  //创建容器，存放个人信息和所属城市
                  //HashMaphm = new HashMap();
                  LinkedHashMaphm = new LinkedHashMap();
                 
                  //添加
                  hm.put(newPerson("小明",23),"上海");
                  hm.put(newPerson("小李",22),"江苏");
                  hm.put(newPerson("老王",44),"北京");       
                  hm.put(newPerson("小强",32),"浙江");       
 
 
                  //调用entrySet()返回set集合
                  Set>entrySet = hm.entrySet();
                 
                  //set迭代器
                  for(Iterator>it = entrySet.iterator();it.hasNext();){
                           //获取set中元素
                           Map.Entryentry = it.next();
                           //获取key值
                           Personkey = entry.getKey();
                           //获取value值
                           Stringvalue = entry.getValue();
                          
                           System.out.println(key.name+":"+key.age+",地址:"+value);
                  }
        }
}
 
 
  
10-常用对象API(集合框架-Map集合练习-记录字母次数思路).avi
 
  
练习:字符串“fdgavcbsacdfs“获取字符串中，每一个字母出现的次数；要求打印的结果是：a(2)b(1)…..;
 
  
11-常用对象API(集合框架-Map集合练习-记录字母次数代码).avi
 
  
 
  
import java.util.*;
 
class CharCountInString {
       
        public static voidmain(String[] main){
                 
                  //待处理的字符串
                  String str ="fdgavcbsacdfs";
                 
                  showCharCount(str);
        }
       
        public static voidshowCharCount(String s){
                  //首先需要遍历字符串每一个字符。放在数组中最好，当然也可以通过截取的方式。
                 
                  //把字符串变成字符数组，便于遍历
                  char[] ch =s.toCharArray();
                 
                  //创建Map集合,因为是从a开始的，所以是按键排序的，用TreeMap
                  TreeMaptm = new TreeMap();
                 
                  //for循环遍历
                  for(int i=0;i>entrySet = tm.entrySet();
                 
                  for(Iterator>it = entrySet.iterator();it.hasNext();){
                           Map.Entryentry = it.next();
                           Characterkey = entry.getKey();
                           Integervalue = entry.getValue();
                          
                           System.out.print(key+"("+value+")");
                  }
                 
        }
}
 
  
 
  
 
  
12-常用对象API(集合框架-Map集合练习-Map查表法).avi
 
  
  有映射关系，都可以用Map
 
  
 
  

                            
                        
                    
                    
                    

                    
                    
                    

                
                

                    
                

            
        
    
    

        
你可能感兴趣的:(java学习)

        

            

                
    
                    
  • JAVA学习笔记之23种设计模式学习
                        victorfreedom
Java技术设计模式androidjava常用设计模式
                        
    博主最近买了《设计模式》这本书来学习，无奈这本书是以C++语言为基础进行说明，整个学习流程下来效率不是很高，虽然有的设计模式通俗易懂，但感觉还是没有充分的掌握了所有的设计模式。于是博主百度了一番，发现有大神写过了这方面的问题，于是博主迅速拿来学习。一、设计模式的分类总体来说设计模式分为三大类：创建型模式，共五种：工厂方法模式、抽象工厂模式、单例模式、建造者模式、原型模式。结构型模式，共七种：适配器
    
                    
    • 
                    
  • 3 java学习之路从就近原则和this关键字开始
                        Daijunxi_cpu
学习javajvmide笔记经验分享开发语言
                        
    求博文多多人看是我写的很烂吗？就近原则以上图举例就近原则，输出age但是成员变量和局部变量变量名age冲突了,就近原则就起效果了，离输出语句近的变量就被使用了。但是要是想用上面那个成员变量咋办？别怕，this会给出答案！！！使用了this关键字就会指向成员变量。就这样比较简单咱们上案例打字太麻烦了直接上视频！kk2024-09-1321-23-42录的视频，真的很烂给大家磕一个构造器kk2024-
    
                    
    • 
                    
  • 大二上学期详细学习计划
                        学会沉淀。
学习
                        
    本学习完成目标：项目：书籍：《mysql必知必会》《java核心技术卷》（暂时）加强JavaSE的学习，掌握Java核心Mysql+sql（把牛客上的那50道sql语句题写完）git+maven完成springboot项目（跟着黑马敲）对于每天的Java学习进行记录算法：刷题（多去刷cf上的题，每周15道）针对最近比赛薄弱的地方加强练习（图论，字符串，动态规划，搜索）cf先上1400，牛客和atc
    
                    
    • 
                    
  • Java学习Day12------字符流、字符缓冲流、转换流、对象操作流程
                        挨踢农民工dsh
JavaSE学习java
                        
    字符流、字符缓冲流、转换流、对象操作流程字符流FileWriterFileReader字符缓冲流转换流对象操作流字符流（1）概述：采用字节流读取数据的时候，容易出现乱码问题，这个时候就需要使用字节流而不是字符流（字节流一次只能读取一个字节,无法确定码表的情况下,转换的过程当中，就会出现乱码，GBK是两个字节进行转换，UTF-8是三个字节进行转换）（2）常见的编码表  a)ASCII码表  b)GB
    
                    
    • 
                    
  • Java学习路线：从零基础到高级开发者的完整指南
                        何遇mirror
java
                        
    初学者入门指南1.环境搭建安装JDK:下载并安装最新版本的JDK（JavaDevelopmentKit）。配置环境:设置JAVA_HOME环境变量，并将bin目录添加到PATH中。选择IDE:使用Eclipse、IntelliJIDEA或其他任何你喜欢的Java集成开发环境。2.Java基础知识HelloWorld:编写你的第一个Java程序。基本语法:学习变量、数据类型（原始类型、包装类型）、运
    
                    
    • 
                    
  • Java学习——lambda表达式
                        Roderick888888
java学习python
                        
    一、Lambda表达式前瞻知识什么是Lambda表达式？可以将Lambda表达式理解为一个匿名函数；Lambda表达式允许将一个函数作为另外一个函数的参数；我们可以把Lambda表达式理解为是一段可以传递的代码（将代码作为实参）,也可以理解为函数式编程，将一个函数作为参数进行传递。为什么要引入Lambda表达式？Lambda表达式能够让程序员的编程更加高效lambda表达式和方法引用使用前提：函数
    
                    
    • 
                    
  • Java学习中，强制类型转换时，没有检查兼容性，引发 ClassCastException怎么办？
                        Itmastergo
java学习开发语言
                        
    Java是一门强类型语言，这意味着在编译时，变量的数据类型已经确定。然而，在实际开发过程中，可能会遇到将对象转换为其他类型的需求，这时就会涉及到类型转换问题。Java提供了自动类型转换和强制类型转换两种方式来处理不同类型之间的转换。自动类型转换（隐式转换）是指编译器在满足某些条件的情况下，自动将一个类型的值转换为另一个兼容类型的值。例如，int类型的变量可以自动转换为double类型。然而，并不是
    
                    
    • 
                    
  • Java学习之路：实践项目与进阶学习--创建一个图书管理系统
                        Dreams°123
java数据库开发语言springspringbootintellijideaintellij-idea
                        
    前言：上一篇学习了入门级知识，留了一份作业，其实创建一个图书管理系统是一个很好的实践项目，可以帮助你掌握数据库操作、前端开发和基本的CRUD（创建、读取、更新、删除）操作，数据库存储书籍信息，以及一个基本的用户界面。项目结构后端:使用Java和SpringBoot实现RESTfulAPI。数据库:使用H2数据库进行书籍信息存储。（也可使用mysql数据库设计，详情可参考：《MySQL数据库课程设计
    
                    
    • 
                    
  • Java 学习路线：适合小白的超细学习路线及实例代码
                        Dreams°123
后端javaeclipsejvmspringtomcatideintellij-idea
                        
    Java学习路线：适合小白的超细学习路线及实例代码一、入门基础1.1、Java基础语法1.2、面向对象编程(OOP)二、核心Java编程2.1、数据结构和算法基础2.2、输入输出(I/O)三、进阶Java编程3.1、多线程编程3.2、网络编程四、高级应用4.1、数据库编程4.2、Web开发4.3、框架与库五、实践项目与进阶学习（留作业啦）5.1、实践项目5.2、持续学习一、入门基础1.1、Java
    
                    
    • 
                    
  • Java学习路线
                        纣王家子迎新
javajava学习
                        
    一、Java基础阶段‌Java语言基础‌：数据类型与变量：了解Java中的基本数据类型（如int、float、double等）和引用数据类型，掌握变量的声明、初始化和使用。运算符与表达式：学习Java中的算术运算符、关系运算符、逻辑运算符等，以及它们的使用规则和优先级。流程控制：掌握条件语句（if-else）、循环语句（for、while、do-while）和跳转语句（break、continue
    
                    
    • 
                    
  • 2022年自学Java就业全面学习路线
                        正等正觉*
Javajava开发语言spring编程语言后端
                        
    很多人私信问我们公司的技术栈是什么，如果今年打算学习Java应该主要学习哪些内容，这篇文章我就以一线互联网大厂的标准，为大家罗列出2022年的Java学习的主要内容，内容可能有点多，因为我是以我们公司年薪30万的Java工程师标准写的，如果需要这些知识点的各种资料，我可以免费分享给大家使用，都是我们公司内部培训员工的高质量资料。需要以下全部视频教程以及文字资料可以在文章末尾处添加我微信名片获取。J
    
                    
    • 
                    
  • 程序员自黑的梗！产品经理：功能实现起来很简单！——程序员：牛
                        小宇java

                        
    在这个盛行自黑的时代，作为全宇宙最神秘最会自黑的程序员群体，他们其实是非常可爱并且努力工作的一群人。所以，如果你的身边有程序员朋友，要多多关心他哦~小编相信这里有很多学习java的朋友，小编整理了一份java方面的学习资料，想要获取的可以加我的java学习群的哟，928204055。欢迎爱学习Java的你们。《桃花庵–程序员版》写字楼里写字间，写字间中程序员；程序人员写程序，又将程序换酒钱；酒醒只
    
                    
    • 
                    
  • Java学习-MyBatis学习(二)
                        丢爸
javajava学习mybatis
                        
    代码下载MyBatis核心配置文件jdbc.driver=com.mysql.cj.jdbc.Driverjdbc.url=jdbc:mysql://192.168.29.201:3306/mybatisjdbc.username=rootjdbc.password=123456-->-->设置配置文件模板①复制要创建模板的配置文件内容②③MyBatis获取参数值Mybatis获取参数值的两种方式
    
                    
    • 
                    
  • Effective Java学习笔记---------方法
                        年糕coder
EffectiveJava学习笔记java
                        
    检查参数的有效性使用Objects.requireNonNull方法来检查是否是null每当编写方法或者构造器的时候，应该考虑它的参数有哪些限制，应该把这些限制写到文档中，并且在这个方法体的开头处，通过显示的检查来实施这些限制必要时进行保护性拷贝Data已经过时了，不应该在新代码中使用（newData（））对于构造器的每一个可变参数进行保护性拷贝，例如：packagecodeTemplate.ef
    
                    
    • 
                    
  • 大厂高频面试题复习JAVA学习笔记-学习路线
                        addaduvyhup
java开发语言
                        
    对于应届生，要找到一份java工作，你得大概学会：java基础：javase、jvm、juc、gc、mysql、jdbc，计网计组Java微服务基础Maven→Gradle→Spring6→SpringMVC→MyBatis→MyBatisPlus→SSM->Redis7->SpringBoot2->SpringCloudjava微服务生态:Git-Docker-Elasticsearch→Zoo
    
                    
    • 
                    
  • JAVA学习-练习试用Java实现“通配符匹配”
                        守护者170
java学习java学习
                        
    问题：给定一个字符串(s)和一个字符模式(p)，实现一个支持'?'和'*'的通配符匹配。'?'可以匹配任何单个字符。'*'可以匹配任意字符串（包括空字符串）。两个字符串完全匹配才算匹配成功。说明:s可能为空，且只包含从a-z的小写字母。p可能为空，且只包含从a-z的小写字母，以及字符?和*。示例1:输入:s="aa"p="a"输出:false解释:"a"无法匹配"aa"整个字符串。示例2:输入:s
    
                    
    • 
                    
  • Java学习 - 数据结构与算法 - 有序数组去重详解
                        泡芙萝莉酱
Javajava学习开发语言算法数据结构
                        
    问题给定一个有序数组，要删除数组重复出现的元素，使得每个元素只出现一次，然后返回移除重复数组后的新长度；示例：假设给定一个数组nums=[1,2,4,4]，删除重复出现的元素4后，原数组变成nums=[1,2,4]，此时新的数组长度为3；解决思路数组原地操作数组原地操作，此时无需创建新的数组，只需要在原来的数组上操作即可。相当于首先要找到数组中重复的元素，然后将重复的元素移除，此时就涉及到数组中的
    
                    
    • 
                    
  • JAVA学习你走对了吗？
                        wc沐风

                        
    在新手刚接触java这门语言的时候，是不是非常的迷茫，不知道从哪里学，怎么学习。没有一个明确的目标，也没有学习的方法。放眼望去，百度上搜索，都是琳琅满目的培训班和文章。但是看过去，却发现没有具体的办法和可实施性。学习Java的第一步是安装好JDK，写一个HelloWorld，其实JDK的学习没有那么难。JDK的安装其实JDK的安装也没有想象的那么难，跟着我一步一步来，其实你会发现，真的特别简单1、
    
                    
    • 
                    
  • Java学习｜Java基础知识
                        进击的小白菜
javajava学习开发语言
                        
    目录类与对象继承封装多态高级话题实践项目类与对象定义与创建类:定义一组具有相同属性和行为的对象的模板。对象:根据类模板创建的实体。示例代码publicclassPerson{Stringname;intage;publicPerson(Stringname,intage){this.name=name;this.age=age;}publicvoidsayHello(){System.out.pr
    
                    
    • 
                    
  • Java学习day-20：多线程
                        开源oo柒

                        
    一、程序、进程、线程1.程序Program：是一个静态的概念，一般对应于操作系统中的一个可执行文件。2.进程：执行中的程序叫做进程(Process)，是一个动态的概念。现代的操作系统都可以同时启动多个进程。（1）特点：1）进程是程序的一次动态执行过程，占用特定的地址空间。2）每个进程由3部分组成：cpu、data、code。每个进程都是独立的，保有自己的cpu时间，代码和数据，即便用同一份程序产生
    
                    
    • 
                    
  • Java为枚举类创建成员变量_Java学习——枚举类
                        陈宇卿
Java为枚举类创建成员变量
                        
    Java学习——枚举类摘要：本文主要介绍了Java的枚举类。部分内容来自以下博客：https://www.cnblogs.com/sister/p/4700702.htmlhttps://blog.csdn.net/zhou520yue520/article/details/80952404为什么使用枚举类枚举类更加直观，类型安全。使用常量会有以下几个缺陷：类型不安全。若一个方法中要求传入季节这个
    
                    
    • 
                    
  • JAVA学习-练习试用Java实现“杨辉三角 II”
                        守护者170
java学习java学习
                        
    问题：给定一个非负索引rowIndex，返回「杨辉三角」的第rowIndex行。在「杨辉三角」中，每个数是它左上方和右上方的数的和。示例1:输入:rowIndex=3输出:[1,3,3,1]示例2:输入:rowIndex=0输出:[1]示例3:输入:rowIndex=1输出:[1,1]提示:0getRow(introwIndex){List>triangle=newArrayListrow=new
    
                    
    • 
                    
  • JAVA学习-练习试用Java实现“数据流的中位数”
                        守护者170
java学习学习java
                        
    问题：中位数是有序列表中间的数。如果列表长度是偶数，中位数则是中间两个数的平均值。例如，[2,3,4]的中位数是3[2,3]的中位数是(2+3)/2=2.5设计一个支持以下两种操作的数据结构：voidaddNum(intnum)-从数据流中添加一个整数到数据结构中。doublefindMedian()-返回目前所有元素的中位数。示例：addNum(1)addNum(2)findMedian()->
    
                    
    • 
                    
  • JAVA学习-深入研究容器.List的功能方法
                        守护者170
java学习java学习list开发语言
                        
    Java中的List接口是Collection接口的子接口之一，它扩展了Collection接口，提供了一系列用于操作和管理有序集合的方法。一、List接口的功能方法以及它们的特点如下：1.添加元素：可以使用`add(Ee)`方法在列表的末尾添加一个元素，也可以使用'add(intindex,Eelement)'方法将元素插入到指定位置。2.删除元素：可以使用'remove(Objecto)'方法
    
                    
    • 
                    
  • “全栈2019”Java多线程第五十二章：LockSupport等待截止时间
                        人人都是程序员

                        
    难度初级学习时间10分钟适合人群零基础开发语言Java开发环境JDKv11IntelliJIDEAv2018.3文章原文链接“全栈2019”Java多线程第五十二章：LockSupport等待截止时间下一章“全栈2019”Java多线程第五十三章：ThreadLocal简单介绍学习小组加入同步学习小组，共同交流与进步。方式一：加入编程圈子。方式二：关注头条号Gorhaf，私信“Java学习小组”。
    
                    
    • 
                    
  • 推荐一篇 学习SQL 的文章
                        @Carey
java零基础开始sql数据库
                        
    学习java，当然避不开数据库的知识，个人认为好学好理解的一篇文章，推荐给大家SQL语法基础知识总结|JavaGuide「Java学习+面试指南」一份涵盖大部分Java程序员所需要掌握的核心知识。准备Java面试，首选JavaGuide！https://javaguide.cn/database/sql/sql-syntax-summary.html#sql-%E8%AF%AD%E6%B3%95希
    
                    
    • 
                    
  • 适合大学生的java后台学习方法
                        万年星光

                        
    原文转载https://blog.csdn.net/m0_37907797/article/details/115548456?utm_source=app&app_version=4.5.8姓名：魏子勋学号20009101910学院：竹园三号书院【嵌牛导读】本文主要介绍了对于大学生来说适合的java学习路径【嵌牛鼻子】java后端学习【嵌牛提问】如何快速高效的学java后台开发【嵌牛正文】一、J
    
                    
    • 
                    
  • JAVA-案例练习-基础进阶复习
                        W.KN
JAVA学习笔记java笔记
                        
    关于JAVA学习后的一些复习题目，提供一些解法和总结一下自己的学习问题。目录1.集合的灵活应用需求：代码实现2.数据分割转换和统计需求：代码实现3.休息日计算需求：代码实现4.数组模拟需求代码实现5.数组排列需求代码实现6.链表问题需求*7.问题总结1.集合的灵活应用需求：目前有100名囚犯，每个囚犯的编号是1~200之间的随机数。现在要求依次随机生成1~100名囚犯的编号，要求这些囚犯的编号是不
    
                    
    • 
                    
  • 软件设计之MySQL(9)
                        柳叶寒
软件设计之MySQLmysql数据库
                        
    软件设计之MySQL(9)此篇应在JavaSE之后进行学习:路线图推荐：【Java学习路线-极速版】【Java架构师技术图谱】Navicat可以在软件管家下载``使用navicat连接mysql数据库创建数据库、表、转储sql文件，导入sql数据MySQL数据库入门到大牛，mysql安装到优化，百科全书级，全网天花板资料可以去尚硅谷官网免费领取学习内容：触发器窗口函数使用(MySQL新特性)公用表
    
                    
    • 
                    
  • java学习感受
                        王聪_强化班

                        
    通过几天的java学习，说实话，每天最多的事情就是写完了删，删完了写，很多时候就是写到烦，写到不想写，感觉随时随刻暴脾气都要上来。觉得自己好笨，跟猪一样。每天脑袋都处于晕的状态，感觉自己都不知道自己写的啥。
    
                    
    • 
                                
  • 安装数据库首次应用
                                    Array_06
javaoraclesql
                                    
    可是为什么再一次失败之后就变成直接跳过那个要求 
enter full pathname of java.exe的界面 
 
 
这个java.exe是你的Oracle 11g安装目录中例如：【F:\app\chen\product\11.2.0\dbhome_1\jdk\jre\bin】下的java.exe 。不是你的电脑安装的java jdk下的java.exe！ 
注意第一次，使用SQL D
    
                                
    • 
                                
  • Weblogic Server Console密码修改和遗忘解决方法
                                    bijian1013
Welogic
                                    
            在工作中一同事将Weblogic的console的密码忘记了，通过网上查询资料解决，实践整理了一下。 
一.修改Console密码 
        打开weblogic控制台，安全领域 --> myrealm -->&n
    
                                
    • 
                                
  • IllegalStateException: Cannot forward a response that is already committed
                                    Cwind
javaServlets
                                    
    对于初学者来说，一个常见的误解是：当调用 forward() 或者 sendRedirect() 时控制流将会自动跳出原函数。标题所示错误通常是基于此误解而引起的。   示例代码：   
protected void doPost() {
    if (someCondition) {
        sendRedirect();
    }
    forward(); // Thi
    
                                
    • 
                                
  • 基于流的装饰设计模式
                                    木zi_鸣
设计模式
                                    
    当想要对已有类的对象进行功能增强时，可以定义一个类，将已有对象传入，基于已有的功能，并提供加强功能。 
自定义的类成为装饰类 
 
模仿BufferedReader，对Reader进行包装，体现装饰设计模式 
 
装饰类通常会通过构造方法接受被装饰的对象，并基于被装饰的对象功能，提供更强的功能。 
装饰模式比继承灵活，避免继承臃肿，降低了类与类之间的关系 
 
装饰类因为增强已有对象，具备的功能该
    
                                
    • 
                                
  • Linux中的uniq命令
                                    被触发
linux
                                    
    Linux命令uniq的作用是过滤重复部分显示文件内容，这个命令读取输入文件，并比较相邻的行。在正常情 况下，第二个及以后更多个重复行将被删去，行比较是根据所用字符集的排序序列进行的。该命令加工后的结果写到输出文件中。输入文件和输出文件必须不同。如 果输入文件用“- ”表示，则从标准输入读取。 
AD： 
uniq [选项] 文件 
说明：这个命令读取输入文件，并比较相邻的行。在正常情况下，第二个
    
                                
    • 
                                
  • 正则表达式Pattern
                                    肆无忌惮_
Pattern
                                    
    正则表达式是符合一定规则的表达式，用来专门操作字符串，对字符创进行匹配，切割，替换，获取。 
  
例如，我们需要对QQ号码格式进行检验 
规则是长度6~12位  不能0开头  只能是数字，我们可以一位一位进行比较，利用parseLong进行判断，或者是用正则表达式来匹配[1-9][0-9]{4,14} 或者 [1-9]\d{4,14} 
&nbs
    
                                
    • 
                                
  • Oracle高级查询之OVER (PARTITION BY ..)
                                    知了ing
oraclesql
                                    
    一、rank()/dense_rank() over(partition by ...order by ...) 
 
现在客户有这样一个需求，查询每个部门工资最高的雇员的信息，相信有一定oracle应用知识的同学都能写出下面的SQL语句： 
 
 select e.ename, e.job, e.sal, e.deptno  
  from scott.emp e,  
       (se
    
                                
    • 
                                
  • Python调试
                                    矮蛋蛋
pythonpdb
                                    
    原文地址： 
http://blog.csdn.net/xuyuefei1988/article/details/19399137 
1、下面网上收罗的资料初学者应该够用了，但对比IBM的Python 代码调试技巧： 
 
IBM：包括 pdb 模块、利用 PyDev 和 Eclipse 集成进行调试、PyCharm 以及 Debug 日志进行调试： 
 
http://www.ibm.com/d
    
                                
    • 
                                
  • webservice传递自定义对象时函数为空，以及boolean不对应的问题
                                    alleni123
webservice
                                    
    今天在客户端调用方法 
NodeStatus status=iservice.getNodeStatus(). 
 
结果NodeStatus的属性都是null。 
 
进行debug之后，发现服务器端返回的确实是有值的对象。 
 
后来发现原来是因为在客户端，NodeStatus的setter全部被我删除了。 
本来是因为逻辑上不需要在客户端使用setter， 结果改了之后竟然不能获取带属性值的
    
                                
    • 
                                
  • java如何干掉指针，又如何巧妙的通过引用来操作指针————>说的就是java指针
                                    百合不是茶

                                    
    C语言的强大在于可以直接操作指针的地址，通过改变指针的地址指向来达到更改地址的目的,又是由于c语言的指针过于强大，初学者很难掌握， java的出现解决了c，c++中指针的问题 java将指针封装在底层，开发人员是不能够去操作指针的地址，但是可以通过引用来间接的操作： 
  
定义一个指针p来指向a的地址（&是地址符号）： 
        
    
                                
    • 
                                
  • Eclipse打不开，提示“An error has occurred.See the log file ***/.log”
                                    bijian1013
eclipse
                                    
    打开eclipse工作目录的\.metadata\.log文件，发现如下错误： 
 
!ENTRY org.eclipse.osgi 4 0 2012-09-10 09:28:57.139 
!MESSAGE Application error 
!STACK 1 
java.lang.NoClassDefFoundError: org/eclipse/core/resources/IContai
    
                                
    • 
                                
  • spring aop实例annotation方法实现
                                    bijian1013
javaspringAOPannotation
                                    
            在spring aop实例中我们通过配置xml文件来实现AOP，这里学习使用annotation来实现，使用annotation其实就是指明具体的aspect,pointcut和advice。1.申明一个切面(用一个类来实现)在这个切面里,包括了advice和pointcut 
AdviceMethods.jav
    
                                
    • 
                                
  • [Velocity一]Velocity语法基础入门
                                    bit1129
velocity
                                    
    用户和开发人员参考文档 
http://velocity.apache.org/engine/releases/velocity-1.7/developer-guide.html 
  注释 
1.行级注释## 
2.多行注释#*  *# 
  变量定义 
使用$开头的字符串是变量定义，例如$var1, $var2, 
  赋值 
使用#set为变量赋值，例
    
                                
    • 
                                
  • 【Kafka十一】关于Kafka的副本管理
                                    bit1129
kafka
                                    
    1. 关于request.required.acks 
  
request.required.acks控制者Producer写请求的什么时候可以确认写成功，默认是0， 
0表示即不进行确认即返回。 
1表示Leader写成功即返回，此时还没有进行写数据同步到其它Follower Partition中 
-1表示根据指定的最少Partition确认后才返回，这个在 
  
Th
    
                                
    • 
                                
  • lua统计nginx内部变量数据
                                    ronin47
lua nginx　 统计
                                    
    server {
    listen 80;
    server_name photo.domain.com;
    location /{set $str $uri;
        content_by_lua '
            local url = ngx.var.uri
            local res = ngx.location.capture(
    
                                
    • 
                                
  • java-11.二叉树中节点的最大距离
                                    bylijinnan
java
                                    
    
import java.util.ArrayList;
import java.util.List;


public class MaxLenInBinTree {

	/*
	 a.			1
	 		   /  \
	 		  2    3
	 		 / \  / \
	 		4   5 6  7
	 	max=4	pass "root"
	 
    
                                
    • 
                                
  • Netty源码学习-ReadTimeoutHandler
                                    bylijinnan
javanetty
                                    
     
ReadTimeoutHandler的实现思路： 
开启一个定时任务，如果在指定时间内没有接收到消息，则抛出ReadTimeoutException 
这个异常的捕获，在开发中，交给跟在ReadTimeoutHandler后面的ChannelHandler，例如 
 
 

private final ChannelHandler timeoutHandler =
	new ReadTim
    
                                
    • 
                                
  • jquery验证上传文件样式及大小(好用)
                                    cngolon
文件上传jquery验证
                                    
    <!DOCTYPE html>
<html>
<head>
    <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
    <script src="jquery1.8/jquery-1.8.0.
    
                                
    • 
                                
  • 浏览器兼容【转】
                                    cuishikuan
css浏览器IE
                                    
    浏览器兼容问题一：不同浏览器的标签默认的外补丁和内补丁不同 
 
问题症状：随便写几个标签，不加样式控制的情况下，各自的margin 和padding差异较大。 
 
碰到频率:100% 
 
解决方案：CSS里    *{margin:0;padding:0;} 
 
备注：这个是最常见的也是最易解决的一个浏览器兼容性问题，几乎所有的CSS文件开头都会用通配符*来设
    
                                
    • 
                                
  • Shell特殊变量：Shell $0, $#, $*, $@, $?, $$和命令行参数
                                    daizj
shell$#$?特殊变量
                                    
    前面已经讲到，变量名只能包含数字、字母和下划线，因为某些包含其他字符的变量有特殊含义，这样的变量被称为特殊变量。例如，$ 表示当前Shell进程的ID，即pid，看下面的代码：   
 
  $echo $$  
   
运行结果 
29949 
   特殊变量列表   变量 含义   $0 当前脚本的文件名   $n 传递给脚本或函数的参数。n 是一个数字，表示第几个参数。例如，第一个
    
                                
    • 
                                
  • 程序设计KISS 原则-------KEEP IT SIMPLE, STUPID!
                                    dcj3sjt126com
unix
                                    
    翻到一本书，讲到编程一般原则是kiss：Keep It Simple, Stupid.对这个原则深有体会，其实不仅编程如此，而且系统架构也是如此。 
 KEEP IT SIMPLE, STUPID! 编写只做一件事情，并且要做好的程序；编写可以在一起工作的程序，编写处理文本流的程序，因为这是通用的接口。这就是UNIX哲学.所有的哲学真 正的浓缩为一个铁一样的定律，高明的工程师的神圣的“KISS 原
    
                                
    • 
                                
  • android Activity间List传值
                                    dcj3sjt126com
Activity
                                    
    第一个Activity： 
import java.util.ArrayList;import java.util.HashMap;import java.util.List;import java.util.Map;import android.app.Activity;import android.content.Intent;import android.os.Bundle;import a
    
                                
    • 
                                
  • tomcat 设置java虚拟机内存
                                    eksliang
tomcat 内存设置
                                    
    转载请出自出处：http://eksliang.iteye.com/blog/2117772 
http://eksliang.iteye.com/ 
常见的内存溢出有以下两种: 
java.lang.OutOfMemoryError: PermGen space  
java.lang.OutOfMemoryError: Java heap space 
  
------------
    
                                
    • 
                                
  • Android 数据库事务处理
                                    gqdy365
android
                                    
    使用SQLiteDatabase的beginTransaction()方法可以开启一个事务，程序执行到endTransaction() 方法时会检查事务的标志是否为成功，如果程序执行到endTransaction()之前调用了setTransactionSuccessful() 方法设置事务的标志为成功则提交事务，如果没有调用setTransactionSuccessful() 方法则回滚事务。事
    
                                
    • 
                                
  • Java 打开浏览器
                                    hw1287789687
打开网址open浏览器open browser打开url打开浏览器
                                    
    使用java 语言如何打开浏览器呢? 
我们先研究下在cmd窗口中,如何打开网址 
使用IE 打开 
D:\software\bin>cmd /c start iexplore http://hw1287789687.iteye.com/blog/2153709 
使用火狐打开 
D:\software\bin>cmd /c start firefox http://hw1287789
    
                                
    • 
                                
  • ReplaceGoogleCDN：将 Google CDN 替换为国内的 Chrome 插件
                                    justjavac
chromeGooglegoogle apichrome插件
                                    
    Chrome Web Store 安装地址： https://chrome.google.com/webstore/detail/replace-google-cdn/kpampjmfiopfpkkepbllemkibefkiice 
 
 由于众所周知的原因，只需替换一个域名就可以继续使用Google提供的前端公共库了。 同样，通过script标记引用这些资源，让网站访问速度瞬间提速吧
    
                                
    • 
                                
  • 进程VS.线程
                                    m635674608
线程
                                    
    资料来源： 
http://www.liaoxuefeng.com/wiki/001374738125095c955c1e6d8bb493182103fac9270762a000/001397567993007df355a3394da48f0bf14960f0c78753f000 1、Apache最早就是采用多进程模式 2、IIS服务器默认采用多线程模式 3、多进程优缺点 优点： 
多进程模式最大
    
                                
    • 
                                
  • Linux下安装MemCached
                                    字符串
memcached
                                    
    前提准备：1. MemCached目前最新版本为：1.4.22，可以从官网下载到。2. MemCached依赖libevent，因此在安装MemCached之前需要先安装libevent。2.1 运行下面命令，查看系统是否已安装libevent。[root@SecurityCheck ~]# rpm -qa|grep libevent libevent-headers-1.4.13-4.el6.n
    
                                
    • 
                                
  • java设计模式之--jdk动态代理（实现aop编程）
                                    Supanccy2013
javaDAO设计模式AOP
                                    
        与静态代理类对照的是动态代理类，动态代理类的字节码在程序运行时由Java反射机制动态生成，无需程序员手工编写它的源代码。动态代理类不仅简化了编程工作，而且提高了软件系统的可扩展性，因为Java 反射机制可以生成任意类型的动态代理类。java.lang.reflect 包中的Proxy类和InvocationHandler 接口提供了生成动态代理类的能力。 
&
    
                                
    • 
                                
  • Spring 4.2新特性-对java8默认方法(default method)定义Bean的支持
                                    wiselyman
spring 4
                                    
    2.1 默认方法(default method) 
 
 java8引入了一个default medthod; 
 用来扩展已有的接口,在对已有接口的使用不产生任何影响的情况下,添加扩展 
 使用default关键字 
 Spring 4.2支持加载在默认方法里声明的bean 
  
2.2 
 
 将要被声明成bean的类 
  
public class DemoService {
    
    
                                
    •