程序博客网 > java高级架构师视频

黑马程序员_Java基础_集合框架1

来源：互联网 发布：java高级架构师视频 编辑：程序博客网 时间：2024/04/20 09:58

一、集合框架(体系概述)

为什么会出现集合框架（集合类）？

面向对象语言对事物的体现都是以对象的形式，所以为了方便对多个对象的操作，就对对象进行存储，集合就是存储对象最常用的一种方式。

数组和集合框架是容器，有何不同？

数组虽然也可以存储对象，但长度是固定的；集合长度可变。数组中可以存储基本数据类型，集合只能存储对象。

集合框架的特点：

集合只用于存储对象，集合长度可变，集合可以存储不同类型的对象。

 

为什么会出现这么多容器呢？

因为每一个容器对数据的存储方式不同。这个存储方式称之为：数据结构。

二、集合框架(共性方法)

[java] view plaincopy
  1. /* 
  2.  
  3. 集合框架(共性方法)： 
  4.  
  5. 1.add方法的参数类型是Object，以便接受任意类型的对象 
  6. 2.集合中存储的都是对象的引用（地址）。 
  7.  
  8. */  
  9. import java.util.*;  
  10. class CollectionDemo   
  11. {  
  12.     public static void main(String[] args)   
  13.     {  
  14.         base_method();  
  15.         base_method_2();      
  16.     }  
  17.   
  18.     public static void base_method()  
  19.     {  
  20.         //创建一个集合容器。使用Collection接口的子类ArrayList  
  21.         ArrayList a1=new ArrayList();  
  22.   
  23.         a1.add("java01");//添加元素   add(Object obj);  
  24.         a1.add("java02");  
  25.         a1.add("java03");  
  26.         a1.add("java04");  
  27.   
  28.         sop("原集合："+a1);//打印  
  29.         sop("java03是否存在："+a1.contains("java03"));  
  30.         sop("集合是否为空？ "+a1.isEmpty());  
  31.         sop("size:"+a1.size());//获取集合长度。  
  32.         a1.remove("java02");//移除java02  
  33.         sop("删除java02后的集合："+a1);//打印  
  34.         a1.clear();//清空集合  
  35.         sop("清空后的集合："+a1);//打印  
  36.   
  37.     }  
  38.     public static void base_method_2()  
  39.     {  
  40.           
  41.         ArrayList a1=new ArrayList();  
  42.   
  43.         a1.add("java01");  
  44.         a1.add("java02");  
  45.         a1.add("java03");  
  46.         a1.add("java04");  
  47.   
  48.         ArrayList a2=new ArrayList();  
  49.   
  50.         a2.add("java01");  
  51.         a2.add("java02");  
  52.         a2.add("java05");  
  53.         a2.add("java06");  
  54.   
  55.         a1.retainAll(a2);//a1中存放和a2的交集  
  56.         sop("a1:"+a1);  
  57.         sop("a2:"+a2);  
  58.   
  59.         a1.removeAll(a2);//移除a1中a2存在的所有元素  
  60.         sop("a1:"+a1);  
  61.         sop("a2:"+a2);  
  62.   
  63.     }  
  64.     public static void sop(Object obj)  
  65.     {  
  66.         System.out.println(obj);  
  67.     }  
  68. }  


三、集合框架(迭代器)

迭代器：集合的取出元素的方式。

[java] view plaincopy
  1. /* 
  2. 迭代器： 
  3. 集合的取出元素的方式。 
  4. */  
  5. import java.util.*;  
  6. class CollectionDemo   
  7. {  
  8.     public static void main(String[] args)   
  9.     {  
  10.         method_get();  
  11.     }  
  12.     public static void method_get()  
  13.     {  
  14.         ArrayList a1=new ArrayList();  
  15.   
  16.         a1.add("java01");  
  17.         a1.add("java02");  
  18.         a1.add("java03");  
  19.         a1.add("java04");  
  20.   
  21.         /* 
  22.         Iterator it=a1.iterator();//获取迭代器，用于取出集合中的元素。 
  23.         while(it.hasNext()) 
  24.         { 
  25.             sop(it.next()); 
  26.         } 
  27.         */  
  28.   
  29.         for(Iterator it=a1.iterator();it.hasNext();)//及时释放Iterator  
  30.         {  
  31.             sop(it.next());  
  32.         }  
  33.     }  
  34.     public static void sop(Object obj)  
  35.     {  
  36.         System.out.println(obj);  
  37.     }  
  38. }  


四、集合框架(List集合共性方法)

[java] view plaincopy
  1. /* 
  2. Collection 
  3.     |--List:元素是有序的，同时元素可以重复，因为该集合体系有索引。 
  4.     |--Set:元素是无序的，元素不可重复，因为该集合体系有没有索引。 
  5.  
  6. List: 
  7. 特有方法。凡是可以操作角标的方法都是该体系特有的方法： 
  8. 增： 
  9.     add(index,element);  
  10.     addAll(index,element); 
  11. 删： 
  12.     remove(index); 
  13. 改： 
  14.     set(intdex,element); 
  15. 查： 
  16.     get(intdex); 
  17.     subList(from,to); 
  18.     ListIterator(); 
  19.  
  20. */  
  21. import java.util.*;  
  22. class ListDemo   
  23. {  
  24.     public static void main(String[] args)   
  25.     {  
  26.         ArrayList a1=new ArrayList();  
  27.   
  28.         a1.add("java01");  
  29.         a1.add("java02");  
  30.         a1.add("java03");  
  31.         a1.add("java04");  
  32.   
  33.         sop("原集合："+a1);  
  34.         a1.add(1,"java09");//在指定位置添加  
  35.         sop(a1);  
  36.   
  37.         a1.remove(2);  
  38.         sop(a1);  
  39.   
  40.         a1.set(2,"java007");//在指定位置修改  
  41.         sop(a1);  
  42.   
  43.         sop("get{2}:"+a1.get(2));//在指定位置获取  
  44.   
  45.         for(int i=0;i<a1.size();i++)//获取全部  
  46.         {  
  47.             System.out.println("a["+i+"]="+a1.get(i));  
  48.         }  
  49.   
  50.         Iterator it=a1.iterator();  
  51.   
  52.         while(it.hasNext())//用迭代器  
  53.         {  
  54.             sop("next:"+it.next());  
  55.         }  
  56.   
  57.         //通过indexOf获取对象的位置  
  58.         sop("index:"+a1.indexOf("java02"));  
  59.   
  60.         List sub=a1.subList(1,3);  
  61.         sop("sub:"+sub);  
  62.   
  63.     }  
  64.     public static void sop(Object obj)  
  65.     {  
  66.         System.out.println(obj);  
  67.     }  
  68. }  


五、集合框架(ListIterator)

[java] view plaincopy
  1. /* 
  2. Collection 
  3.     |--List:元素是有序的，同时元素可以重复，因为该集合体系有索引。 
  4.     |--Set:元素是无序的，元素不可重复，因为该集合体系有没有索引。 
  5.  
  6. List: 
  7. 特有的迭代器。ListIterator是Iterator的子接口。 
  8. 在迭代时，不可以通过集合对象的方法操作集合中的元素，因为会发生 
  9. java.util.ConcurrentModificationException异常。 
  10. 所以在迭代器时，只能用迭代其的方法操作元素，可是Iterator方法是有限的。 
  11. 如果想要其它的操作如：添加，修改等，就需要使用其自接口ListIterator。 
  12. 该接口只能通过List集合的listIterator方法获取。 
  13.  
  14. */  
  15. import java.util.*;  
  16. class ListDemo   
  17. {  
  18.     public static void main(String[] args)   
  19.     {  
  20.         //演示列表迭代器  
  21.         ArrayList a1=new ArrayList();  
  22.   
  23.         a1.add("java01");  
  24.         a1.add("java02");  
  25.         a1.add("java03");  
  26.         a1.add("java04");  
  27.           
  28.         sop(a1);  
  29.           
  30.         ListIterator li=a1.listIterator();  
  31.         while(li.hasNext())  
  32.         {  
  33.             Object obj=li.next();  
  34.             if(obj.equals("java02"))  
  35.                 li.add("java009");  
  36.         }  
  37.         sop("hasNext():"+li.hasNext());  
  38.         sop("hasPrevious():"+li.hasPrevious());  
  39.         sop(a1);  
  40.   
  41.         /* 
  42.  
  43.         //在迭代过程中准备添加或删除元素 
  44.         Iterator it=a1.iterator(); 
  45.  
  46.         while(it.hasNext())//用迭代器 
  47.         { 
  48.             Object obj=it.next(); 
  49.             if(obj.equals("java02")) 
  50.                 //a1.add("java008"); 
  51.                 it.remove();//将java02的引用从集合中移除 
  52.             sop("obj="+obj); 
  53.         } 
  54.         sop(a1); 
  55.  
  56.         */  
  57.   
  58.     }  
  59.     public static void sop(Object obj)  
  60.     {  
  61.         System.out.println(obj);  
  62.     }  
  63. }  


六、集合框架(List集合具体对象的特点)

Collection

|--List:元素是有序的，同时元素可以重复，因为该集合体系有索引。

|--ArrayList:底层的数据结构使用数组。特点：查询速度很快。但是增删稍慢。线程不 同步。

|--LinkedList:底层的数据结构使用链表。特点：增删速度很快，查询稍慢。

|--Vector:底层是数组数据结构。线程同步。被ArrayList替代。

七、集合框架(Vector中的枚举)

[java] view plaincopy
  1. /* 
  2. Vector特有取出方式。 
  3. 发现枚举和迭代器很像。 
  4. 其实枚举和迭代是一样的，为什么出现迭代呢？ 
  5. 因为枚举的名称以及方法的名称都过长，所以被迭代器取代了，枚举郁郁而终了。 
  6. */  
  7. import java.util.*;  
  8. class VectorDemo   
  9. {  
  10.     public static void main(String[] args)   
  11.     {  
  12.         Vector v=new Vector();  
  13.   
  14.         v.add("java01");  
  15.         v.add("java02");  
  16.         v.add("java03");  
  17.         v.add("java04");  
  18.   
  19.         Enumeration en=v.elements();  
  20.         while(en.hasMoreElements())  
  21.         {  
  22.             System.out.println(en.nextElement());  
  23.         }  
  24.     }  
  25. }  


八、集合框架(LinkedList)

[java] view plaincopy
  1. /* 
  2. LinkedList特有方法： 
  3. addFirst(): 
  4. addLast(): 
  5. 添加元素 
  6.  
  7. getFirst(): 
  8. getLast(): 
  9. 获取元素，但不删除元素 
  10.  
  11. removeFirst(): 
  12. removeLast(): 
  13. 获取元素，删除元素。如果集合中没有元素，会出现NoSuchElementException异常。 
  14.  
  15. 所以在JDK1.6出现了替代方法： 
  16. offerFirst() 
  17. offerLast() 
  18. 添加元素 
  19.  
  20. peekFirst() 
  21. peekLast() 
  22. 获取元素，但不删除元素。如果集合中没有元素，会出返回null 
  23.  
  24. pollFirst() 
  25. pollLast() 
  26. 获取元素，删除元素。如果集合中没有元素，会出返回null 
  27.  
  28. */  
  29. import java.util.*;  
  30. class LinkedListDemo   
  31. {  
  32.     public static void main(String[] args)   
  33.     {  
  34.         LinkedList link1=new LinkedList();  
  35.   
  36.         link1.addFirst("java01");  
  37.         link1.addFirst("java02");  
  38.         link1.addFirst("java03");  
  39.         link1.addFirst("java04");  
  40.   
  41.         sop("link1="+link1);  
  42.   
  43.         LinkedList link2=new LinkedList();  
  44.   
  45.         link2.addLast("java01");  
  46.         link2.addLast("java02");  
  47.         link2.addLast("java03");  
  48.         link2.addLast("java04");  
  49.   
  50.         sop("link2="+link2);  
  51.   
  52.         sop(link2.getFirst());  
  53.         sop(link2.getLast());  
  54.         sop("size="+link2.size());  
  55.   
  56.         sop(link2.removeFirst());//如果列表为空，会抛出null异常  
  57.         sop(link2.removeLast());  
  58.         sop("size="+link2.size());  
  59.   
  60.         while(!link2.isEmpty())//全部获取  
  61.         {  
  62.             sop(link2.removeFirst());  
  63.         }  
  64.     }  
  65.     public static void sop(Object obj)  
  66.     {  
  67.         System.out.println(obj);  
  68.     }  
  69.   
  70. }  


九、集合框架(LinkedList练习)

[java] view plaincopy
  1. /* 
  2. 使用LinkedList模拟一个堆栈或队列的数据结构。 
  3. 堆栈：先进后出。 
  4. 队列：先进先出。 
  5. */  
  6. import java.util.*;  
  7. class DuiLie//队列  
  8. {  
  9.     private LinkedList link;  
  10.     DuiLie()  
  11.     {  
  12.         link=new LinkedList();  
  13.     }  
  14.     public void myAdd(Object obj)  
  15.     {  
  16.         link.addFirst(obj);  
  17.     }  
  18.     public Object myGet()  
  19.     {  
  20.         return link.removeLast();//堆栈：return link.removeFirst();  
  21.     }  
  22.     public boolean isNull()  
  23.     {  
  24.         return link.isEmpty();  
  25.     }  
  26. }  
  27. class LinkedListTest   
  28. {  
  29.     public static void main(String[] args)   
  30.     {  
  31.         DuiLie d1=new DuiLie();  
  32.         d1.myAdd("java01");  
  33.         d1.myAdd("java02");  
  34.         d1.myAdd("java03");  
  35.         d1.myAdd("java04");  
  36.   
  37.         while(!d1.isNull())  
  38.         {  
  39.             System.out.println(d1.myGet());  
  40.         }  
  41.     }  
  42. }  


十、集合框架(ArrayList练习)

[java] view plaincopy
  1. /* 
  2. 去除ArrayList集合中重复的元素。 
  3. */  
  4. import java.util.*;  
  5. class ArrayListTest   
  6. {  
  7.     public static void sop(Object obj)  
  8.     {  
  9.         System.out.println(obj);  
  10.     }  
  11.     public static void main(String[] args)   
  12.     {  
  13.         ArrayList a1=new ArrayList();  
  14.   
  15.         a1.add("java01");  
  16.         a1.add("java01");  
  17.         a1.add("java03");  
  18.         a1.add("java02");  
  19.         a1.add("java03");  
  20.         a1.add("java04");  
  21.         a1.add("java04");  
  22.         a1.add("java04");  
  23.   
  24.         sop("原数据："+a1);  
  25.   
  26.         sop("去除重复元素："+singleElement(a1));  
  27.     }  
  28.     public static ArrayList singleElement(ArrayList a1)  
  29.     {  
  30.         //定义一个临时容器  
  31.         ArrayList a2=new ArrayList();  
  32.   
  33.         Iterator it=a1.iterator();  
  34.   
  35.         while(it.hasNext())//next()调用一次，就hasNext()判断一次。  
  36.         {  
  37.             Object obj=it.next();  
  38.             if(!a2.contains(obj))  
  39.                 a2.add(obj);  
  40.         }  
  41.   
  42.         return a2;  
  43.     }  
  44. }  


[java] view plaincopy
  1. /* 
  2. 将自定义对象作为元素存到ArrayList集合中，并去除重复元素。 
  3. 比如：存人对象。同姓名同龄人，视为同一个人。为重复元素。 
  4.  
  5. 思路： 
  6. 1.对人描述，将数据封装成人对象。 
  7. 2.定义容器，将人存入。 
  8. 3.取出。 
  9.  
  10.  
  11. 结论：List集合判断元素是否相同，依据的是元素的equals方法。 
  12. */  
  13. import java.util.*;  
  14. class Person  
  15. {  
  16.     private String name;  
  17.     private int age;  
  18.     Person(String name,int age)  
  19.     {  
  20.         this.name=name;  
  21.         this.age=age;  
  22.     }  
  23.     public String getName()  
  24.     {  
  25.         return name;  
  26.     }  
  27.     public int getAge()  
  28.     {  
  29.         return age;  
  30.     }  
  31.     public boolean equals(Object obj)//重写Object类的equals方法  
  32.     {  
  33.         if(!(obj instanceof Person))  
  34.             return false;  
  35.         Person p=(Person)obj;  
  36.           
  37.         System.out.println(this.name+"..........."+p.name);//测试contains调用equals  
  38.   
  39.         return this.name.equals(p.name)&&this.age==p.age;  
  40.     }  
  41. }  
  42. class ArrayListTest2   
  43. {  
  44.     public static void sop(Object obj)  
  45.     {  
  46.         System.out.println(obj);  
  47.     }  
  48.     public static void main(String[] args)   
  49.     {  
  50.         ArrayList a1=new ArrayList();  
  51.         a1.add(new Person("lisi01",30));  
  52.         a1.add(new Person("lisi02",32));  
  53.         a1.add(new Person("lisi03",33));  
  54.         a1.add(new Person("lisi04",34));  
  55.         a1.add(new Person("lisi01",30));  
  56.         a1.add(new Person("lisi02",32));  
  57.         a1.add(new Person("lisi03",33));  
  58.         a1.add(new Person("lisi04",34));  
  59.   
  60.         a1=singleElement(a1);//去除重复  
  61.   
  62.         Iterator it=a1.iterator();  
  63.           
  64.         while(it.hasNext())  
  65.         {  
  66.             Person p=(Person)it.next();  
  67.             sop("姓名："+p.getName()+"\t年龄："+p.getAge());  
  68.         }  
  69.     }  
  70.     public static ArrayList singleElement(ArrayList a1)  
  71.     {  
  72.         //定义一个临时容器  
  73.         ArrayList a2=new ArrayList();  
  74.   
  75.         Iterator it=a1.iterator();  
  76.   
  77.         while(it.hasNext())//next()调用一次，就hasNext()判断一次。  
  78.         {  
  79.             Object obj=it.next();  
  80.             if(!a2.contains(obj))//底层调用equals()方法  
  81.                 a2.add(obj);  
  82.         }  
  83.   
  84.         return a2;  
  85.     }  
  86.   
  87.   
  88. }  


十一、集合框架(HashSet)

[java] view plaincopy
  1. /* 
  2. |--Set:元素是无序的，元素不可重复，因为该集合体系有没有索引。 
  3.     |--HashSet:底层数据结构是哈希表。 
  4.     |--TreeSet: 
  5.  
  6. Set集合的功能和Collection是一致的。 
  7. */  
  8. import java.util.*;  
  9. class HashSetDemo   
  10. {  
  11.     public static void sop(Object obj)  
  12.     {  
  13.         System.out.println(obj);  
  14.     }  
  15.     public static void main(String[] args)   
  16.     {  
  17.         HashSet hs=new HashSet();  
  18.         sop(hs.add("java01"));  
  19.         sop(hs.add("java01"));  
  20.         hs.add("java02");  
  21.         hs.add("java03");  
  22.         hs.add("java03");  
  23.         hs.add("java04");  
  24.   
  25.         Iterator it=hs.iterator();  
  26.         while(it.hasNext())  
  27.         {  
  28.             sop(it.next());  
  29.         }  
  30.     }  
  31. }  


十二、集合框架(HashSet存储自定义对象)

[java] view plaincopy
  1. /* 
  2. 给hashSet集合中存入自定义对象。 
  3. 比如：存人对象。同姓名同龄人，视为同一个人。为重复元素。 
  4.  
  5. HashSet是如何保证元素唯一性的呢？ 
  6. 那是通过元素的两个方法：hashCode和equals来完成的 
  7. 如果元素的hashCode值相同，才会判断equals是否为true。 
  8. 如果元素的hashCode值不相同，不会调用equals 
  9. */  
  10. import java.util.*;  
  11. class Person  
  12. {  
  13.     private String name;  
  14.     private int age;  
  15.     Person(String name,int age)  
  16.     {  
  17.         this.name=name;  
  18.         this.age=age;  
  19.     }  
  20.     public String getName()  
  21.     {  
  22.         return name;  
  23.     }  
  24.     public int getAge()  
  25.     {  
  26.         return age;  
  27.     }  
  28.     public int hashCode()//重写Object类的hashCode方法  
  29.     {  
  30.         System.out.println(this.name+"....hashCode");  
  31.         return 60;  
  32.     }  
  33.     public boolean equals(Object obj)//重写Object类的equals方法  
  34.     {  
  35.         if(!(obj instanceof Person))  
  36.             return false;  
  37.         Person p=(Person)obj;  
  38.           
  39.         System.out.println(this.name+".....equals....."+p.name);//测试contains调用equals  
  40.   
  41.         return this.name.equals(p.name)&&this.age==p.age;  
  42.     }  
  43. }  
  44. class HashSetDemo   
  45. {  
  46.     public static void sop(Object obj)  
  47.     {  
  48.         System.out.println(obj);  
  49.     }  
  50.     public static void main(String[] args)   
  51.     {  
  52.         HashSet hs=new HashSet();  
  53.         hs.add(new Person("a1",11));  
  54.         hs.add(new Person("a2",12));  
  55.         hs.add(new Person("a3",13));  
  56.         hs.add(new Person("a2",12));  
  57.   
  58.         Iterator it=hs.iterator();  
  59.   
  60.         while(it.hasNext())  
  61.         {  
  62.             Person p=(Person)it.next();  
  63.             sop("姓名："+p.getName()+"\t年龄："+p.getAge());  
  64.         }  
  65.     }  
  66. }  


 

hashCode改进后：

[java] view plaincopy
  1. public int hashCode()//重写Object类的hashCode方法  
  2. {  
  3.         System.out.println(this.name+"....hashCode");  
  4.         return this.name.hashCode()+age*13;//age*13是确保唯一性。  
  5. }  

 


十三、集合框架(HashSet判断和删除的依据)

[java] view plaincopy
  1. /* 
  2. 注意，对于判断元素是否存在以及删除等操作，依赖元素的 
  3. hashCode和equals方法。 
  4. */  
  5. import java.util.*;  
  6. class Person  
  7. {  
  8.     private String name;  
  9.     private int age;  
  10.     Person(String name,int age)  
  11.     {  
  12.         this.name=name;  
  13.         this.age=age;  
  14.     }  
  15.     public String getName()  
  16.     {  
  17.         return name;  
  18.     }  
  19.     public int getAge()  
  20.     {  
  21.         return age;  
  22.     }  
  23.     public int hashCode()//重写Object类的hashCode方法  
  24.     {  
  25.         System.out.println(this.name+"....hashCode");  
  26.         return this.name.hashCode()+age*13;  
  27.     }  
  28.     public boolean equals(Object obj)//重写Object类的equals方法  
  29.     {  
  30.         if(!(obj instanceof Person))  
  31.             return false;  
  32.         Person p=(Person)obj;  
  33.           
  34.         System.out.println(this.name+".....equals....."+p.name);//测试contains调用equals  
  35.   
  36.         return this.name.equals(p.name)&&this.age==p.age;  
  37.     }  
  38. }  
  39. class HashSetDemo   
  40. {  
  41.     public static void sop(Object obj)  
  42.     {  
  43.         System.out.println(obj);  
  44.     }  
  45.     public static void main(String[] args)   
  46.     {  
  47.         HashSet hs=new HashSet();  
  48.         hs.add(new Person("a1",11));  
  49.         hs.add(new Person("a2",12));  
  50.         hs.add(new Person("a3",13));  
  51.         hs.add(new Person("a2",12));  
  52.           
  53.         hs.remove(new Person("a3",13));//删除元素  
  54.         sop("a1:"+hs.contains(new Person("a1",11)));//获取元素是否存在  
  55.         Iterator it=hs.iterator();  
  56.   
  57.         while(it.hasNext())  
  58.         {  
  59.             Person p=(Person)it.next();  
  60.             sop("姓名："+p.getName()+"\t年龄："+p.getAge());  
  61.         }  
  62.     }  
  63. }  
0 0
java高级架构师视频 java高级架构师视频
原创粉丝点击
热门IT博客
淘宝嘉年华活动规则淘宝嘉年华活动规则
鲁班预算软件下载鲁班预算软件下载
招商银行软件中心招聘
软件开发工程师证
返利机器人软件
北京大数据工程师招聘
自建邮件服务器 知乎
模拟架子鼓软件手机
数据恢复 pdf
php url跳转代码
网络连接不可用红叉
jstor知乎
上海驾校知乎
七煌网络官网
pl sql 查询用户密码
网络信息安全培训资料
初学java简历项目经验
linux 应用层 gpio
手机淘宝怎么用券
客服源码
热门问题 老师的惩罚 人脸识别 我在镇武司摸鱼那些年 重生之率土为王 我在大康的咸鱼生活 盘龙之生命进化 天生仙种 凡人之先天五行 春回大明朝 姑娘不必设防，我是瞎子 蜗杆传动的特点 蜗杆升降机 蜗轮蜗杆减速 蜗杆加工方法 包络环面蜗杆减速机 蜗轮蜗杆润滑油 蜗杆蜗轮 减速机蜗轮蜗杆 蜗杆加工 蜗杆减速机原理 齿轮蜗杆减速机 微型蜗轮蜗杆减速器 微型蜗杆减速器 蜗轮蜗杆双输出减速机 包络蜗杆减速机 涡轮蜗杆减速器 蜗杆计算公式 蜗杆头数 数控车床加工蜗杆 平面二次包络环面蜗杆减速机 平面二次包络环面蜗杆 蜗行 蜗行的意思 蜗行意思 蜗行的拼音 涡轮蜗杆自锁 涡轮蜗杆减速电机 蜗杆减速机 涡轮蜗杆减速机自锁 涡轮蜗杆减速机型号 wpo涡轮蜗杆减速机 涡轮蜗杆油 涡轮蜗杆受力分析 蜗轮减速箱 蜗轮增压发动机优缺点 蜗轮伸缩蝶阀 蜗轮蜗杆生产厂 小型蜗轮蜗杆减速机 蜗轮蜗杆自锁条件 蜗轮蜗杆减速机型号 rv蜗轮蜗杆减速机

程序博客网，程序员的互联网技术博客家园。csdn论坛精品 msdn技术资料都在这里