黑马程序员——第14天——（API）集合框架（ArraryList，LinkedList，HashSet）

最新推荐文章于 2024-04-26 23:50:44 发布
最新推荐文章于 2024-04-26 23:50:44 发布
阅读量472 收藏
点赞数
分类专栏： 黑马程序员 文章标签： 黑马程序员 集合框架 ArraryList LinkedList HashSet
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lgl092389/article/details/42524947
版权



黑框中的是重点



ArraryList

import java.util.*;

/*
1，add方法的参数类型是Object。以便接受任意类型对象。

2，集合中存储的都是对象的引用（地址）

什么是迭代器？
其实就是集合的取出元素方法。
见demo1
*/

class CollectionDemo
{
	public static void main(String[] args) 
	{
		//创建一个集合容器。使用Collection接口的子类。ArrayList
		ArrayList al = new ArrayList();

		//1,添加元素。
		a1.add("java01");//add(Object obj);
		a1.add("java02");
		a1.add("java03");
		a1.add("java04");

		//打印原集合。
		sop("原集合："+al);

		//3,删除元素。
		//al.remove("java02");
		//al.clear();//清空集合。

		//4，判断元素。
		sop("java03是否存在："+al.contains("java03"));
		sop("集合是否为空？"+al.isEmpty());

		//2，获取个数。集合长度。
		//sop("size:"+al.size);
		
		//打印改变后的集合。
		sop(al);
	}

	public static void sop(Object obj)
	{
		System.out.println(obj);
	}
}

 
class CollectionDemo1
{
	public static void main(String[] args) 
	{
<span style="white-space:pre">		</span>method_2();
		method_get();
	}

	public static void method_get()
	{
		ArrayList al = new ArrayList();

		//1，添加元素。
		al.add("java01");//add(Object obj);
		al.add("java02");
		al.add("java03");
		al.add("java04");
		
		/*
		Iterator it = al.iterator();//获取迭代,用于取出集合中的元素。

		while(it.hasNext())
		{
			sop(it.next());			
		}
		*/
		
		for(Iterater it = al.iterater(); it.hasNext();)
		{
			sop(it.next());
		}
	}

	public static void method_2()
	{
		ArrayList al1 = new ArrayList();

		al1.add("java01");
		al1.add("java02");
		al1.add("java03");
		al1.add("java04");

		ArrayList al2 = new ArrayList();
		al1.add("java03");
		al1.add("java04");
		al1.add("java05");
		al1.add("java06");

		//al1.retainAll(al2);//取交集，al1中只会保留al2中相同的元素。
<span style="white-space:pre">		</span>//al1.removeAll(al2);
	}
	
	public static void sop(Object obj)
	{
		System.out.println(obj);
	}
}

迭代器


List
/*
Collection
|--List:元素是有序的，元素可以重复，因为该集合体系有索引。
|--ArrayList:底层的数据结构使用的是数组结构。特点：查找速度很快。但是增删稍慢。线程不同步。默认长度是10，超过，15%延长。
|--LinkedList:底层使用链表数据结构。特点：增删速度很快，查询稍慢。
|--Vector:底层是数组数据结构。线程同步，被ArraryList替代了。超过，100%延长，

|--Set: 元素是无序，元素不可以重复。
List：
特有方法。凡是可以操作角标的方法都是该体系特有的方法。


增
add(index,element);
addAll(index,Collection);

删
remove(index);

改
set(index,element);

查
get(index);
subList(from,to);
listIterater();


List集合特有的迭代器，ListIterator是Iterator的子接口。


在迭代时，不可以通过集合对象的方法操作集合中的元素，
因为会发生ConcurrentModificationException并发访问异常。


所以，在迭代时，只能用迭代器的方法操作元素，可是Iterator方法是有限的。
只能对元素进行判断，取出，删除的操作。
如果想要其他的操作，如添加，修改等，就需要使用其子接口，ListIterator。


该接口只能通过List集合的listIterator方法获取。
*/

import java.util.*;
class ListDemo 
{
	public static void sop(Object obj)
	{
		System.out.println(obj);
	}
	public static void method()
<span style="white-space:pre">	</span>{
<span style="white-space:pre">		</span>ArrayList al = new ArrayList();

		//添加元素
		al.add("java01");
		al.add("java02");
		al.add("java03");

		sop("原集合是："+al);
		//在指定位置添加元素。
		al.add(1,"java09");

		//删除指定位置的元素。
		//al.remove(2);

		//修改元素。
		//al.set(2,"java007");

		//通过角标获取元素。
		sop("get(1):"+al.get(1));

		sop(al);

		//获取所有元素。
		for(int x=0;x<al.size;x++)
		{
			Systme.out.println("al("+x+")="+al.get(x));
		}

		Iterator it = al.iterator();

		while(it.hasNext())
		{
			sop("next:"+it.next());
		}

		//通过indexOf获取对象的位置。
		sop("index="+al.indexOf("java02"));

		List sub = al.subList(1,3);

		sop("sub="+sub);
<span style="white-space:pre">	</span>}

<span style="white-space:pre">	</span>public static void main(String[] args)
<span style="white-space:pre">	</span>{
<span style="white-space:pre">		</span>//演示列表迭代器
<span style="white-space:pre">		</span>ArrayList al = new ArrayList();


<span style="white-space:pre">		</span>//添加元素
<span style="white-space:pre">		</span>al.add("java01");
<span style="white-space:pre">		</span>al.add("java02");
<span style="white-space:pre">		</span>al.add("java03");
<span style="white-space:pre">		</span>
<span style="white-space:pre">		</span>sop(al);

<span style="white-space:pre">		</span>ListIterator li = al.listIterator();

<span style="white-space:pre">		</span>//sop("hasPrevious():"+li.hasPrevious());

<span style="white-space:pre">		</span>while(li.hasNext())
<span style="white-space:pre">		</span>{
<span style="white-space:pre">			</span>Object obj = li.next();

<span style="white-space:pre">			</span>if (obj.equals("java02"))
<span style="white-space:pre">				</span>//li.add("java009");
<span style="white-space:pre">				</span>li.set("java006");
<span style="white-space:pre">		</span>}

<span style="white-space:pre">		</span>while(li.hasPrevious())
<span style="white-space:pre">		</span>{
<span style="white-space:pre">			</span>sop("pre:"+li.previous());
<span style="white-space:pre">		</span>}
//<span style="white-space:pre">		</span>sop("hasNext():"+li.hasNext());
//<span style="white-space:pre">		</span>sop("hasPrevious()":+li.hasPrevious());


<span style="white-space:pre">		</span>sop(al);

<span style="white-space:pre">		</span>/*
<span style="white-space:pre">		</span>//在迭代过程中，准备添加或删除元素。

<span style="white-space:pre">		</span>Iterator it = al.iterator();

<span style="white-space:pre">		</span>while(it.hasNext())
<span style="white-space:pre">		</span>{
<span style="white-space:pre">			</span>Object obj = it.next();

<span style="white-space:pre">			</span>if(obj.equals("java02"))
<span style="white-space:pre">				</span>//al.add("java008");
<span style="white-space:pre">				</span>it.remove();//将java02的引用从集合中删除了。

<span style="white-space:pre">			</span>sop("obj="+obj);
<span style="white-space:pre">		</span>}
<span style="white-space:pre">		</span>sop(al);
<span style="white-space:pre">		</span>*/
<span style="white-space:pre">	</span>}
}


vector

 

import java.util.*;

/*
枚举就是Vector特有的取出方式。
发现枚举和迭代器很像。
其实枚举和迭代是一样的。

因为枚举的名称以及方法的名称都过长。
所以被迭代器取代了。
枚举郁郁而终了。
*/
class  VectorDemo
{
	public static void main(String[] args) 
	{
		Vector v = new Vector();

		v.add("java01");
		v.add("java02");
		v.add("java03");
		v.add("java04");

		Enumeration en = v.elements();

		while(en.hasMoreElement())
		{
			System.out.println(en.nextElement());
		}
	}
}
 
LinkedList 

 

import java.util.*;
/*
LinkedList:特有方法。
addFirst();
addLast();

getFirst();
getLast();
获取元素，但不删除元素。如果集合中没有元素，会出现NoSuchElementException

removeFirst();
removeLast();
获取元素，但是元素被删除。如果集合中没有元素，会出现NoSuchElementException

在JDK1.6出现了替代方法。

offerFirst();
offerLast();
添加元素

peekFirst();
peekLast();
获取元素，但不删除元素，如果集合中没有元素，会返回null。

pollFirst();
pollLast();
获取元素，但是元素被删除，如果集合中没有元素，会返回null。

*/
class LinkedListDemo 
{
	public static void main(String[] args) 
	{
		LinkedList link = new LinkedList();

		link.addFirst("java01");
		link.addFirst("java02");
		link.addFirst("java03");
		link.addFirst("java04");

		//sop(link);
		sop(link.getFirsst());
		sop(link.getLast());
		sop(link.removeFirst());

		sop("size"+link.size());

		while(!link.isEmpty())
		{
			sop(link.removeFirst());
		}
	}

	
	public static void sop(Object obj)
	{
		System.out.println(obj);
	}
}
 
 

 
LinkedList练习 

 

 使用LinkedList模拟一个堆栈或者队列数据结构。 

 

 堆栈：先进后出   如同一个杯子。 

 队列：先进先出 First in First out  FIFO  如同一个水管。  

 

 必须会！！！！ 

 

import java.util.*;
class DuiLie
{
	private LinkedList link

	DuiLie()
	{
		link = new LinkedList();
	}

	public void myAdd(Object obj)
	{
		link.addFirst(obj);
	}
	public Object myGet();
	{
		return link.removeLast();//removeFirst();
	}
	public boolean isNull();
	{
		return link.isEmpty();
	}
}


class LinkedListTest 
{
	public static void main(String[] args) 
	{
		DuiLie dl = new DuiLie();
		dl.myAdd("java01");
		dl.myAdd("java02");
		dl.myAdd("java03");
		dl.myAdd("java04");
	
		while(!dl.isNull())
		{
			System.out.println(dl.myGet());
		}
	}
}
 


<strong>去除ArrayList集合中的重复元素。</strong>


 

import java.util.*;


class ArrayListTest 
{
	public static void sop(String str)
	{
		System.out.println(str);
	}

	public static void main(String[] args) 
	{
		ArrayList al = new ArrayList();

		al.add("java01");
		al.add("java02");
		al.add("java01");
		al.add("java02");
		al.add("java01");
		al.add("java03");
		
		/*
		在迭代时循环中next调用一次，就要hasNext判断一次。
		Iterator it = al.iterator();

		while(it.hasNext())
		{
			sop(it.next()+"...."+it.next());
		}
		没有java03的话会出现没有元素异常，
		*/

		/*
		sop(al);

		al = singleElement(al);

		sop(al);
		*/
	}

	public static ArrayList singleElement(ArrayList al)
	{
		//定义一个临时容器。
		ArrayList newal = new ArrayList();

		Iterator it = al.iterator();

		while(it.hasNext())
		{
			Object obj = it.next();
			
			if(!newal.contains(obj))
				newal.add(obj);

		}

	}
}
 

 

<strong>将自定义对象作为元素存到ArrayList集合中，并去除重复元素。</strong>

比如：存人对象。同姓名同年龄，视为同一个人。为重复元素。

思路：
1，对人描述，将数据封装进人对象。
2，定义容器，将人村入。
3，取出。

List集合判断元素是否相同，依据的是元素的equals方法。其他集合不是这样的

 

import java.util.*;

class Person
{
	private String name;
	private int age;
	Person(String name,int age)
	{
		this.name = name;
		this.age = age;
	}
	public boolean equals(Object obj)//覆盖Object类中的equals方法
	{
		if(!(obj instanceof Person))
			return false;

		Person p = (Person)obj;
//		System.out.println(this.name+"...."+p.name);

		return this.name.equals(p.name) && this.age == p.age;
	}
	public String getName()
	{
		return name;
	}
	public int getAge()
	{
		return age;
	}		
}

class ArraryListTest2 
{
	public static void main(String[] args) 
	{
		ArrayList al = new ArrayList();
		al.add(new Person("lisi01",30));//al.add(Object obj)
		al.add(new Person("lisi02",32));
		al.add(new Person("lisi03",33));
		al.add(new Person("lisi04",35));

		//al = singleElement(al);

		//sop("remove03:"+al.remove(new Person"lisi03",33));

		Iterator it = al.iterator();

		while(it.hasNext())
		{
			/*
			Object obj = it.next();
			Person p =(Person)obj;
			*/
			Person p = (Person)it.next();//必须向下转型，不然读取不到
			sop(p.getName()+"::"+p.getAge());
		}

	}
	public static ArrayList singleElement(ArrayList al)
	{
		//定义一个临时容器。
		ArrayList newal = new ArrayList();

		Iterator it = al.iterator();

		while(it.hasNext())
		{
			Object obj = it.next();
			
			if(!newal.contains(obj))
				newal.add(obj);

		}
		return newAl; 
	}
}

 

 
Set集合 

 /* 

 |--Set:元素是无序的（存入和取出的顺序不一定一致），元素不可以重复。 

 
|--HashSet：底层数据结构是哈希表。 

 
HashSet是如何保证元素唯一性的呢？ 

 
是通过元素的两个方法，hashcode和equals来完成 

 
如果元素的HashCode值相同，才会判断equals是否为true. 

 
如果元素的hashCode值不同，不会调用equals。 

 

 

 
注意，对于判断元素是否存在，以及删除等操作，依赖的方法是元素的hashcode和equals方法。 

 
ArraryList只依赖equals方法。 

 
|--TreeSet: 

 

 
Set集合的功能和Collection是一致的。 

 */ 

 

import java.util.*;

class HashSetDemo 
{
	public static void sop(Object obj)
	{
		System.out.println(obj);	
	}
	public static void main(String[] args) 
	{
		HashSet hs = new HashSet();

		sop(has.add("java01"));
		sop(has.add("java01"));
		has.add("java02");
		has.add("java03");
		has.add("java03");
		has.add("java04");

		Iterator it = hs.iterator();

		while(it.next())
		{
			sop(it.next());
		}
	}
}
 

<strong>往hashSet集合中存入自定义对象</strong>
姓名和年龄相同为同一个人，重复元素。
 

import java.util.*;

class HashSetTest 
{
	public static void sop(Object obj)
	{
		System.out.println(str);
	}
	public static void main(String[] args) 
	{
		HashSet hs = new HashSet();

		hs.add(new Person("a1",11));
		hs.add(new Person("a2",12));
		hs.add(new Person("a3",13));
		hs.add(new Person("a4",14));

<span style="white-space:pre">		</span>sop("a1:"+hs.contains(new Person)("a2",12)));

<span style="white-space:pre">		</span>hs.remove(new Person("a4",13));

		Iterator hs = hs.iterator();

		while(it.hasNext())
		{
			Person p = (Person)it.next();
			sop(p.getName()+"::"+p.getAge());
		}
	}
}
class Person
{
	private String name;
	private int age;
	Person(String name,int age)
	{
		this.name = name;
		this.age = age;
	}

	public int hashCode()
	{
		//System.out.println(this.name+"...hashCode");
		return name.hashCode()+age*37;//防止哈希值重复，预防超出int取值范围，所以*37
	}
	public boolean equals(Object obj)
	{
		if(!(obj instanceof Person))
			return false;

		Person p = (Person)obj;
//		System.out.println(this.name+"...."+p.name);

		return this.name.equals(p.name) && this.age == p.age;
	}
	public String getName()
	{
		return name;
	}
	public int getAge()
	{
		return age;
	}		
}
 

 

 

 


                

        

        

    




    

      

        

            

              
                
                  Awizard23
                
              
            

            

                关注
              
            

        

        

          
    
            
  • 
              
                
                
                
                
                      0
                
              
              
    点赞
    
            
    • 
            
  • 
              
                
                
                
              
              
    踩
    
            
    • 
            
  • 
              
                
                
                
                
                    0
                
              
              
    
                
    
                  
                    收藏
                  
                
    
              
    
              
    
                
    
                  觉得还不错?
                  
                    一键收藏
                  
                 
                
    
              
    
            
    • 
          
  • 
            
    
              
              
            
    
              
              
              
                    0
              
            
            
    评论
    
          
    • 
          
  • 
          
    • 
          
  • 
            
              
            
              
    
            
              
                
            
    
          
    • 
        

      

      

            

                专栏目录
          










                



	

		

			

				
					
java集合框架笔记

				
			

			

				

					03-18
				

			

		

		

			
				
List set ArraryList Map java集合框架笔记  基于Array的List，其实就是封装了Array所不具备的一些功能方便我们使用

			
		

	



                

              
                



	

		

			

				
					
浅谈ArraryList扩容机制

				
			

			

				

					12-21
				

			

		

		

			
				
本文主要探讨ArrayList的扩容机制，特别是为何在创建ArrayList时尽量指定集合大小。我们首先来看看ArrayList的两种初始化方式：  1. 直接使用无参数构造器：  `List list1 = new ArrayList();`  这种方式创建的...

			
		

	



                


  
              

                


	

		

			

				
					
api集合_通过弱集合快速改善观察者模式api

				
			

			

				

					weixin_26735419的博客
				

				

					08-14
					
					97
					
				

			

		

		

			
				
api集合Even if you don’t know what the Observer pattern is, there’s a good chance that you’ve applied it in the past. This design pattern is used to create APIs that notify one or more subjects about ch...

			
		

	





	

		

			

				
					
List,Set,Map用法以及区别

				
			

			

				

					weixin_30852367的博客
				

				

					09-27
					
					413
					
				

			

		

		

			
				
List特点：元素有放入顺序，元素可重复Map特点：元素按键值对存储，无放入顺序Set特点：元素无放入顺序，元素不可重复（注意：元素虽然无放入顺序，但是元素在set中的位置是有该元素的HashCode决定的，其位置其实是固定的）List接口有三个实现类：LinkedList，ArrayList，VectorLinkedList：底层基于链表实现，链表内存是散乱的，每一个元素存储本身内存地址...

			
		

	



		

			
		



	

		

			

				
					
List与ArraryList的区别

				
			

			

				

					charly
				

				

					12-18
					
					647
					
				

			

		

		

			
				
区别点List是一个泛型接口，可以实现各种类型的add和remove，不需要进行装箱和拆箱 
ArraryList需要进行拆箱和装箱才能将值进行操作

			
		

	





	

		

			

				
					
Array和ArrayList的区别

				
			

			

				

					weixin_33709590的博客
				

				

					04-08
					
					269
					
				

			

		

		

			
				

Array和ArrayList的区别1. Array类型的变量在声明的同时必须进行实例化(至少得初始化数组的大小)，而ArrayList可以只是先声明。2. Array只能存储同构的对象，而ArrayList可以存储异构的对象。同构的对象是指类型相同的对象，若声明为int[]的数组就只能存放整形数据,string[]只能存放字符型数据,但声明为object[]的数组除外。而ArrayList可...

			
		

	





	

		

			

				
					
黑马程序员——java基础——集合框架

				
			

			

				

					Cathy_ndi的博客
				

				

					08-12
					
					655
					
				

			

		

		

			
				
(1)对象数组概述：
代码注意事项：A:自己的类名不要和我们学习的要使用的API的类名相同。
              B:复制代码的时候，很容易把那个类所在的包也导入过来，容易出现不能理解的问题。
数组既可以存储基本数据类型，也可以存储引用类型。它存储引用类型的时候的数组就叫对象数组。
2:集合(Collection)
      (1)集合的由来?
              我

			
		

	





	

		

			

				
					
javaSE集合框架（一）—— Collection接口

				
			

			

				

					qq_44886213的博客
				

				

					07-25
					
					485
					
				

			

		

		

			
				
javaSE集合框架

			
		

	





	

		

			

				
					
JAVA基础——集合框架（List与Set）

					
最新发布

				
			

			

				

					qq_56438516的博客
				

				

					04-26
					
					1545
					
				

			

		

		

			
				
1．内部基于数组实现的一个集合类。查询比较快，添加和删除相对比较慢2．猜ArrayList中会有哪些功能（方法）： 添加、删除、查询、插入、修改。。。3．不是同步的（存在线程安全问题）1.不能够添加重复元素2．无序（不保证和添加和打印顺序一致）1.通过添加进去的元素的hashCode+eqauls 两者进行比较2．如果两个对象的hashCode相等 并且 两个对象调用equals结果是true 才认为两个元素重复1．无序：不保证（不记录）我们的添加顺序；但是排序了。

			
		

	





	

		

			

				
					
集合详解一、ArraryList和LinkedList

				
			

			

				

					TTDreamTT的博客
				

				

					12-21
					
					398
					
				

			

		

		

			
				
一、数组简介：
参考资料：https://blog.csdn.net/TTDreamTT/article/details/79000291
一、集合架构图：




			
		

	





	

		

			

				
					
C#获取数组中最大最小值的方法

				
			

			

				

					12-25
				

			

		

		

			
				
根据下面函数获取数组中最大最小值即可。调用时候直接传数组范围一个float类型的变量     public float MaxOfList(float[] flotNum)  {  float maxValue = flotNum.ToArray().Max();  return maxValue;...

			
		

	





	

		

			

				
					
js 删除数组的几种方法小结

				
			

			

				

					10-26
				

			

		

		

			
				
在JavaScript中，删除数组元素的方法主要有以下几种，这些方法各有优缺点，适用于不同的场景。  1. `delete` 方法：  ```javascript  var arr = ['a', 'b', 'c'];  delete arr[1];  ```  使用 `delete` 方法会将指定...

			
		

	





	

		

			

				
					
VB6用vbRichClient操作sqlite，支持解密

				
			

			

				

					01-12
				

			

		

		

			
				
vbrichclient的中文例程比较少，网上搜了点文字资料，并简单测了一下  应该说用vbRichClient操作sqlite是个不错的选择，  首先它支持加解密  其次它的版本比其他VB sqlite支持库更新快，像目前已经是sqlite3.9支持...

			
		

	





	

		

			

				
					
黑马程序员Java学习日记（4）集合（一）

				
			

			

				

					zhanghao_abc的专栏
				

				

					07-19
					
					570
					
				

			

		

		

			
				
------- android培训、java培训、期待与您交流！ ----------
 
 
               黑马程序员Java学习日记（4）集合（一）
1.前言：
（1）为什么会出现集合类：
    面向对象对事物的体现都是以对象的形式体现的，所以为了方便对多个对象的操作，就对对象进行存储，集合就是存储对象最常用的的一种方式。
 
（2）数组和集合类的区别：
 

			
		

	





	

		

			

				
					
黑马程序员——第15天——（API）集合框架（TreeSet，泛型）

				
			

			

				

					lgl092389的专栏
				

				

					01-09
					
					552
					
				

			

		

		

			
				
Set:无序，不可以重复元素。
|--HashSet：数据结构是哈希表。线程是非同步的。
保证元素唯一性的原理：判断元素的hashcode值是否相同。
如果相同，还会继续判断元素的equals方法，是否为true.


|--TreeSet: 
可以对Set集合中的元素进行排序。
底层数据结构是二叉树。
保证元素唯一性的依据：
compareTo方法return 0。

			
		

	





	

		

			

				
					
黑马程序员——第10天——（面向对象）包package，包与包之间的访问，导入import

				
			

			

				

					lgl092389的专栏
				

				

					01-06
					
					531
					
				

			

		

		

			
				
package pack;




/*
为了简化类名的书写，使用一个关键字，import。
import 导入的是包中的类。不是包
建议，不要写通配符 * 。需要用到包中的哪个类，就导入哪个类。






c:\myclass


c:\myclass\packb\DemoA.class
c:\myclass\packb\haha\DemoZ.class

			
		

	





	

		

			

				
					
黑马程序员——第5天——（面向对象）构造函数，构造代码块，this关键字

				
			

			

				

					lgl092389的专栏
				

				

					12-31
					
					512
					
				

			

		

		

			
				
第二遍看视频，重新梳理一遍学习中不牢固的地方。
今天看到构造函数这一块，才意识到第一遍学习的时候这块内容就没有真正理解透彻，通过这段时间的学习，当第二次看到这段内容的时候才意识到，曾经遇到过的难题，原来是因为对构造函数掌握的不好造成的。今天就准备仔细梳理一番。




对象一建立就会调用与之相对应的构造函数。

构造函数的作用：可以用于给对象进行初始化。

构造函数小细节：

			
		

	





	

		

			

				
					
arrarylist和linkedlist区别

				
			

			

				

					05-20
				

			

		

		

			
				
ArrayList和LinkedList都是Java中的集合类，它们的实现方式不同，因此在使用时有一些区别。  ArrayList是一个基于动态数组实现的集合类，它可以按照索引来访问其中的元素。当需要从集合中获取元素时，ArrayList的...

			
		

	



              



  
“相关推荐”对你有帮助么？

  

      
    
          
  • 
              
    
                  
                  
              
    
              
    非常没帮助
    
          
    • 
          
  • 
              
    
                  
                  
              
    
              
    没帮助
    
          
    • 
          
  • 
              
    
                  
                  
              
    
              
    一般
    
          
    • 
          
  • 
              
    
                  
                  
              
    
              
    有帮助
    
          
    • 
          
  • 
              
    
                  
                  
              
    
              
    非常有帮助
    
          
    • 
      

      

      

          
          提交
      

      

  




          




        



    





    



      

      

        
      

      





	

		评论	
	

	
	




  

    

      添加红包
      
    

    

      

        
        

          
          
        

        
请填写红包祝福语或标题

      

      

        
        

          
          个
        

        
红包个数最小为10个

      

      

        
        

          
          元
        

        
红包金额最低5元

      

      

        
        

          当前余额3.43元
          前往充值 >
        

      

      

        

          需支付：10.00元
        

        
        
      

    

  





  

    
    
  

  

    
    
  








  

    

      

        

          

            
            
成就一亿技术人!

          

          

        

        

          

          

            领取后你会自动成为博主和红包主的粉丝
            规则
          

        

      

      

        

          

            
              
            
            

              
hope_wisdom
 发出的红包
            

          

        

        

          

          

          

        

      

    

    

  



      
      

      
实付元

      
使用余额支付

      

        

          

            
            点击重新获取
          

        

        
扫码支付

      

      

        
          
            
          
          
        
      

      

        
        钱包余额
          0
          

            
            

              

                
抵扣说明：

                
 1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
 2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

              

            

          

      

      余额充值