Java之集合概述

一、集合概述

java中有好多集合：List，ArrayList，Vector，HashSetTreeSet，它們之間的區別，java集合的框架等等總是很模糊，稱有時間總結下。

     當資料多了需要存儲，需要容器，而資料的個數不確定，無法使用數組，這時可以使用Java中另一個容器－集合，位於java.util 。 

 

   1、集合與陣列的差異？

   ① 陣列的長度是固定的。

       集合的長度是可變的。

   ②陣列中儲存的是相同類型的元素，可以儲存基本資料類型值。

      集合儲存的都是物件。而且物件的類型可以不一致。

 

   2、何時使用集合呢？

        當物件多的時候，先儲存。

   3、集合系統架構圖

  

二、Collection介面

      Collection介面：單列集合類別的根介面

      

      1、List介面：有順序的，則以索引為基礎的，可由索引而精確的運算集合中的元素，允許重複的元素出現。

                 使用List解決插入元素的問題，因為add方法則追加。

                 List介面的特殊方法，皆是圍繞索引來定義的。

                 List取得元素的方式有兩種：其中一個是迭代，另一種是遍歷+get方法。

                 List介面是支援對元素進行curd增刪改查動作的。

             

#   ①Vector:可成長的陣列結構。同步的。效率非常低，已被ArrayList取代。

   ②ArrayList:是陣列結構，長度是可變的（原理建立新陣列+複製陣列），查詢速度很快，增刪較慢，不同步的。 （應用廣）。

  範例：

 1 public class Example01 {
 2     public static void main(String[] args) {
 3         ArrayList list = new ArrayList();  //创建ArrayList集合
 4         list.add("stu1");
 5         list.add("stu2");
 6         list.add("stu3");
 7         list.add("stu4");
 8         System.out.println("集合的长度："+list.size());//获得集合中元素的个数
 9         System.out.println("集合的第二个元素："+list.get(1));//取出并打印指定位置的元素
10     }
11 }

執行結果：

集合的长度：4集合的第二个元素：stu2

   ③LinktedList:是連結結構，增刪速度快，查詢速度慢。可用於實作堆疊，佇列。特有：圍繞頭和為展開定義的。

   堆疊：先進後出First in Last Out FILO 可以理解為手槍彈夾

   佇列：先進先出First in First Out FILO 可以理解為排隊買票

常用方法範例：

 1 public class Example02 {
 2     public static void main(String[] args) {
 3         LinkedList link = new LinkedList();//创建LinkedList集合
 4         link.add("stu1");
 5         link.add("stu2");
 6         link.add("stu3");
 7         link.add("stu4");
 8         System.out.println(link.toString());//取出元素并打印该集合中的元素
 9         link.add(3,"Student"); //向该集合中的指定位置插入元素
10         link.addFirst("First");           //向该集合第一个位置插入元素
11         link.addLast("Last");             //向该集合第一个位置插入元素
12         System.out.println(link);
13         System.out.println(link.getFirst()); //取出该集合第一个元素
14         System.out.println(link.getLast()); //取出该集合最后一个个元素
15         link.remove(3);                //移除该集合中指定位置的元素
16         link.removeFirst();                  //移除该集合中第一个元素
17         link.removeLast();                  //移除该集合中最后一个个元素
18         System.out.println(link);
19     }
20 }

執行結果：

[stu1, stu2, stu3, stu4]
[First, stu1, stu2, stu3, Student, stu4, Last]
First
Last
[stu1, stu2, Student, stu4]

2、Iterator介面

#     集合的取出方式：

     ①建立集合物件

       Collection coll = new ArrayList();

##  # 方法；

       Iterator it = coll.iterator();

      ③使用特定的迭代器物件取得集合中的元素；

##

while (it.hasNext()){
    System.out.println(it.next());
}

      實際開發建議使用以下方法(隨著迭代完成，迭代器隨之變成垃圾被清除，可以減少所佔記憶體)：

for（Iterator it = coll.iterator();it.hasNext();）{
     System.out.println(it.next());
}

#此迭代器無法再迭代的過程中修改數組元素，否則會發生並發修改異常（ConcurrentModificationException）。

3、foreach:

    其實就是增強for循環，用於遍歷Collection和陣列通常只能遍歷元素，不要在遍歷的過程中做對集合元素的操作。

    格式：

######

for（元素数据类型 变量 ：collection集合or数组（））{执行语句}

#########與老式for迴圈的差別？ ######注意：新for迴圈必須有被遍歷的目標。目標只能是Collection或是陣列。 ######建議：遍歷數組時，如果僅為遍歷，可以使用增強for，如果要對數組的元素進行操作，使用老式for循環可以透過角標操作。 ######   範例：########

 1 public class Foreach {
 2     static String [] strs = {"aaa","bbb","ccc"};
 3     public static void main(String[] args) {
 4         //foreach循环遍历数组
 5         for(Object obj : strs){
 6             System.out.println(obj);
 7         }
 8             System.out.println("______________");
 9         //foreach循环遍历数组并修改（修改失败）
10         for (String str : strs){
11             str="ddd";
12         }
13         System.out.println("foreach循环修改后的数组："+strs[0]+","+strs[1]+","+strs[2]);
14         //for循环遍历数组
15         for(int i = 0;i<strs.length;i++){
16             strs[i]="ddd";
17         }
18         System.out.println("普通for循环修改后的数组："+strs[0]+","+strs[1]+","+strs[2]);
19     }
20 }

######執行結果：######

1 aaa
2 bbb
3 ccc
4 ______________
5 foreach循环修改后的数组：aaa,bbb,ccc
6 普通for循环修改后的数组：ddd,ddd,ddd

#########4、ListIterator迭代器## #

Iterator的子类，该列表迭代只有List接口有，而且这个迭代器可以完成在迭代过程中的增删改查动作。

add方法示例：

 1 public class AddDemo {
 2     public static void main(String[] args) {
 3 
 4         //在最前面添加
 5         List<String> list1 = new LinkedList<String>(Arrays.asList(
 6                 new String[] { "a", "b", "c" }));
 7         ListIterator<String> listIterator1 = list1.listIterator();
 8         listIterator1.add("D");
 9         listIterator1.add("E");
10         System.out.println(list1);//[D, E, a, b, c]
11         //在最后面添加
12         List<String> list2 = new LinkedList<String>(Arrays.asList(
13                 new String[] { "a", "b", "c" }));
14         ListIterator<String> listIterator2 = list2.listIterator();
15         while (listIterator2.hasNext()) {
16             listIterator2.next();
17         }
18         listIterator2.add("D");
19         listIterator2.add("E");
20         System.out.println(list2);//[a, b, c, D, E]
21         //在每个元素的前面和后面都添加
22         List<String> list3 = new LinkedList<String>(Arrays.asList(
23                 new String[] { "a", "b", "c" }));
24         ListIterator<String> listIterator3 = list3.listIterator();
25         while (listIterator3.hasNext()) {
26             listIterator3.add("前面");
27             listIterator3.next();
28             listIterator3.add("后面");
29         }
30         System.out.println(list3);//[前面, a, 后面, 前面, b, 后面, 前面, c, 后面]
31         //在指定元素的前面和后面添加
32         List<String> list4 = new LinkedList<String>(Arrays.asList(
33                 new String[] { "a", "b", "c" }));
34         ListIterator<String> listIterator4 = list4.listIterator();
35         while (listIterator4.hasNext()) {
36             if (listIterator4.next().equals("a")) {//现在指向的是a的后面
37                 listIterator4.previous();//先重新指向a的前面，这里不用担心NoSuchElementException
38                 listIterator4.add("前面");//在前面添加元素，添加后还是指向的a的前面
39                 listIterator4.next();//向后【再】移动一位，现在指向的是a的后面
40                 listIterator4.add("后面");//在a的后面添加元素
41             }
42         }
43         System.out.println(list4);//[前面, a, 后面, b, c] 
44     }
45 }

remove方法示例：

 1 public class RemoveDemo {
 2     public static void main(String[] args) {
 3 
 4 // 执行next()或previous()后不能先执行了 add()方法。
 5 // 因为add()方法执行以后，迭代器已经移动了，这样所要删除的目标元素指向不明，会报异常。
 6         //标准的做法：在next之后才能remove
 7         List<String> list2 = new LinkedList<String>(Arrays.asList(
 8                 new String[] { "b", "a", "b", "c", "b", }));
 9         ListIterator<String> listIterator2 = list2.listIterator();
10         while (listIterator2.hasNext()) {
11             if (listIterator2.next().equals("b")) {listIterator2.remove();}
12         }
13         System.out.println(list2);//[a, c]
14 
15         //移除指定范围内的所有元素
16         List<String> list3 = new LinkedList<String>(Arrays.asList(
17                 new String[] { "a", "开始", "b", "c", "d", "结束", "e" }));
18         ListIterator<String> listIterator3 = list3.listIterator();
19         while (listIterator3.hasNext()) {
20             if (listIterator3.next().equals("开始")) {
21                 listIterator3.remove();//注释掉这行代码则不移除"开始"
22                 while (listIterator3.hasNext()) {
23                     if (!listIterator3.next().equals("结束")) {
24                         listIterator3.remove();//remove之后必须再调用next方法后才能再remove
25                     } else {
26                         listIterator3.remove();//注释掉这行代码则不移除"结束"
27                         break;//结束while循环
28                     }
29                 }
30             }
31         }
32         System.out.println(list3);//[a, e]
33         //替换指定元素
34         List<String> list5 = new LinkedList<String>(Arrays.asList(
35                 new String[] { "a", "b", "c" }));
36         ListIterator<String> listIterator5 = list5.listIterator();
37         while (listIterator5.hasNext()) {
38             if (listIterator5.next().equals("b")) {
39                 listIterator5.remove();
40                 listIterator5.add("替换");
41             }
42         }
43         System.out.println(list5);//[a, 替换, c]
44     }
45 }

 

5、Set接口

     不包含重复元素的集合，不保证顺序。而且方法和Collection一致。Set集合取出元素的方式只有一种：迭代器。

     ①HashSet：哈希表结构，不同步，保证元素唯一性的方式依赖于： hashCode（），equals（）方法。查询速度快。哈希值是根据存储位置来计算。

 1 class Student{
 2     private String id;
 3     private String name;
 4     public Student(String id,String name){
 5         this.id = id;
 6         this.name = name;
 7     }
 8 //    重写toString方法
 9     public String toString(){
10         return id+":"+name;
11     }
12 //    重写hashCode方法
13     public int hashCode(){
14         return id.hashCode();//返回id属性的哈希值
15     }
16 //    重写equals方法
17     public boolean equals(Object obj){
18         if(this==obj){                  //判断是否为同一个对象
19             return true;                 //如果是，直接返回true
20         }
21         if (!(obj instanceof Student)){   //判断对象是否Student类型
22             return false;                 //如果对象不是Student类型，返回false
23         }
24         Student stu = (Student)obj;        //将对象强转为Student类型
25         boolean b= this.id.equals(stu.id); //判断id值是否相同
26         return b;                           //返回判断结果
27     }
28 }
29 public class HashSetDemo {
30     public static void main(String[] args) {
31         HashSet set = new HashSet();
32         Student stu1= new Student("1","Jack");
33         Student stu2= new Student("2","Rose");
34         Student stu3= new Student("2","Rose");
35         set.add(stu1);
36         set.add(stu2);
37         set.add(stu3);
38         System.out.println(set);
39     }
40 }

运行结果：

[1:Jack, 2:Rose]
若不重写hashCode()和equals（）方法，则输出结果是：
[2:Rose，1:Jack, 2:Rose]

 

     ②TreeSet：可以对Set集合中的元素进行排序。使用的是二叉树结构。如何保证元素唯一性的？使用的是对象比较方法的结果是否为0，是0，视为相同元素不存。

        元素的排序比较有两种方式：

1. 元素自身具备自然排序，其实就是实现了Comparable接口重写compareTo方法。如果元素自身不具备自然排序，或具备的自然排序不是所需要的，这时只能用第二种方式。

2. 比较器，其实就是在创建TreeSet集合时，在构造函数中指定具体的比较方式。需要定义一个类实现Comparator接口，重写compare方法。

3.  1 class Student implements Comparable{  //定义Student类实现Comparable接口
    2     String name;
    3     int age;
    4     public Student(String name,int age){   //创建构造方法
    5         this.name = name;
    6         this.age = age;
    7     }
    8     public String toString(){    //重写Object类toString（）方法，返回描述信息
    9         return name+":"+age;
   10     }
   11     public int compareTo(Object obj){  //重写Comparable接口compareTo方法
   12         Student s =(Student) obj;   //将比较对象强转为Student类型
   13         if (this.age -s.age>0){       //定义比较方法
   14             return 1;
   15         }
   16         if (this.age-s.age==0){
   17             return this.name.compareTo(s.name);//将比较结果返回
   18         }
   19         return -1;
   20     }
   21 }
   22 public class TreeSetDemo {
   23     public static void main(String[] args) {
   24         TreeSet ts = new TreeSet();
   25         ts.add(new Student("Jack",19));
   26         ts.add(new Student("Rose",18));
   27         ts.add(new Student("Tom",19));
   28         ts.add(new Student("Rose",18));
   29         Iterator it = ts.iterator();
   30         while (it.hasNext()){
   31             System.out.println(it.next());
   32         }
   33     }
   34 }
   运行结果：
   Rose:18
   Jack:19
   Tom:19

   到此为止：在往集合中存储对象时，通常该对象都需要覆盖hashCode，equals，同时实现Comparable接口，建立对象的自然排序。通常还有一个方法也会复写toString();

 

三、Map接口：

      双列集合Map集合的特点：内部存储的都是键key值value对，必须要保证键的唯一性。

      Map集合常用方法

     

①Hashtable---数据结构：哈希表。是同步的，不允许null作为键和值。被HashMap替代。

   子类Properties：属性表，键和值都是字符串，而且可以结合流进行键值操作。唯一一个可以和IO流结合使用的集合类。

②HashMap---数据结构：哈希表。不是同步的，允许null作为键和值。

示例：

 1 public class Example15 {
 2     public static void main(String[] args){
 3       Map map = new HashMap();      //创建Map对象
 4       map.put("1","Jack");     //存储键和值，键相同，值覆盖
 5       map.put("2","Rose");
 6       map.put("3","Lucy");
 7       map.put("3","Mary");
 8       System.out.println("1:"+map.get("1"));//根据键获取值
 9       System.out.println("2:"+map.get("2"));
10       System.out.println("3:"+map.get("3"));
11     }
12 }

Map集合的两种遍历方式：

 1 public class Example16 {
 2     public static void main(String[] args){
 3         //第一种先遍历Map集合中所有的键，再跟据键获取相应的值。
 4         Map map1 = new HashMap();      //创建Map对象
 5         map1.put("1","Jack");     //存储键和值
 6         map1.put("2","Rose");
 7         map1.put("3","Lucy");
 8         Set keySet1 = map1.keySet();          //获取键的集合
 9         Iterator it1 = keySet1.iterator();    
10         while (keySet1.iterator().hasNext()){  // 迭代键的集合
11             Object key = it1.next();
12             Object value = map1.get(key);      //获得每个键所对应的值
13             System.out.println(key+":"+value);
14         }
15         
16         //第二种先获取集合中的所有映射关系，然后从映射关系中取出键和值
17         Map map2 = new HashMap();
18         map2.put("1","Jack");     //存储键和值
19         map2.put("2","Rose");
20         map2.put("3","Lucy");
21         Set entrySet = map2.entrySet();
22         Iterator it = entrySet.iterator();    //获取Iterator对象
23         while (it.hasNext()){
24             Map.Entry entry = (Map.Entry)(it.next()); //获取集合中键值对映射关系
25             Object key = entry.getKey();      //获取Entry中的键
26             Object value = entry.getValue();  //获取Entry中的值
27             System.out.println(key+":"+value);
28         }
29     }
30 }

运行结果：

1:Jack
2:Rose
3:Lucy

 LinkedHashMap：基于链表+哈希表。可以保证map集合有序（存入和取出的顺序一致）。

③TreeMap---数据结构：二叉树，保证键的唯一性，同步的，可以对map集合中的键进行排序。

 1 //按学号从大排到小
 2 public class Example20 {
 3     public static void main(String[] args) {
 4         TreeMap tm = new TreeMap(new MyCompartor());  //传入一个自定义比较器
 5         tm.put("1","Jack");     //存储键和值
 6         tm.put("2","Rose");
 7         tm.put("3","Lucy");
 8         Set keySet = tm.keySet();          //获取键的集合
 9         Iterator it = keySet.iterator();    // 迭代键的集合
10         while (it.hasNext()){
11             Object key = it.next();
12             Object value = tm.get(key);      //获得每个键所对应的值
13             System.out.println(key+":"+value);
14         }
15     }
16 }
17 class MyCompartor implements Comparator{   //自定义比较器
18     public int compare(Object o1, Object o2) {  //实现比较方法
19         String id1 = (String) o1;      //将Object类型的参数强转为String类型
20         String id2 = (String) o2;        
21         return id2.compareTo(id1);     //将比较结果之后的值返回，按字典相反顺序进行排序
22     }
23 }

运行结果：

3:Lucy
2:Rose
1:Jack

 

四、 泛型（parameterized type）

     1、泛型的使用

      体现<数据类型>，<>也是括号，往括号里写都写其实就是在传递参数。

       格式：ArrayList<参数化类型> list = new ArrayList<参数化类型>();

      泛型的优点：安全机制；将运行时期的ClassCastExecption转移到了编译时期变成了编译失败。泛型技术，是给编译器使用的技术。避免了强转的麻烦。

    示例：

 1 public class Example23 {
 2     public static void main(String[] args) {
 3         ArrayList<String> list = new ArrayList<String>();
 4         list.add("String");
 5         list.add("Collection");
 6         for(String str:list){
 7             System.out.println(str);
 8         }
 9     }
10 }

2、自定义泛型：

需求：请自己提供一个容器类。

分析：你要做一个容器类，你就应该知道容器类具备什么基本功能？

添加功能 save（）

获取功能 get（）

要做这样的方法，save是不是应该有参数呢？肯定的。

get（）应该有参数吗？这里我们可以不给形式参数，但是一定要有返回值类型。

基本格式：

void save （参数类型 参数）{…}

返回值类型 get（）{…..}

为了让我们的容器类能够存储任意类型的对象，我就应该给save（）方法中的参数定义为object类型。

当然，get（）方法的返回值类型应该是object类型。

出现问题：A 不兼容类型 B 类型转换异常

需求：自己定义一个泛型类并使用

如何定义一个泛型类呢？

就是把泛型安装其格式加在类上。

格式：

<参数化类型>可以是E、T这样有意义的单词。

使用泛型后，我们可以不用再做类型转换了。

//在创建类时，声明参数类型为T
class 类名<T>{
       T temp;
//在创建save（）方法时，指定参数类型为T
       public void save (T temp){this.temp = temp}
//在创建get()方法时，指定返回值类型为T
       public T get(){
              return temp；
        }
}

示例：

 1 class CachePool<T>{
 2     T temp;
 3     public void save(T temp){
 4         this.temp=temp;
 5     }
 6     public T get() {
 7         return temp;
 8     }
 9 }
10 public class Example26 {
11     public static void main(String[] args) {
12         CachePool<Integer> pool = new CachePool<Integer>();
13         pool.save(new Integer(1));
14         Integer temp = pool.get();
15         System.out.println(temp);
16     }
17 }

五、Collections工具类

     Collections：集合框架中的用于操作集合对象工具类。都是静态方法。

1. 获取Collection最值。

2. 对List集合排序，也可以用二分查找。

3. 对排序逆序。

4. 可以将非同步的集合转变成同步的集合。如：Xxx synchronizedXxx(Xxx) -------List synchronizedList (List)

 //排序操作
 1 public class Example27 {
 2     public static void main(String[] args) {
 3     ArrayList list = new ArrayList();
 4     Collections.addAll(list,"c","z","B","K");
 5     System.out.println("排序前："+list);
 6     Collections.reverse(list);
 7     System.out.println("反转后："+list);
 8     Collections.shuffle(list);
 9     System.out.println("按自然顺序排序后："+list);
10     Collections.sort(list);
11     System.out.println("洗牌后："+list);
12     }
13 }

运行结果：

排序前：[c, z, B, K]
反转后：[K, B, z, c]
按自然顺序排序后：[c, B, K, z]
洗牌后：[B, K, c, z]

<br>

//查找、替换操作

 1 public class Example28 {
 2     public static void main(String[] args) {
 3         ArrayList list = new ArrayList();
 4         Collections.addAll(list,-3,2,9,5,8);
 5         System.out.println("集合中的元素："+list);
 6         System.out.println("集合中的最大元素："+Collections.max(list));
 7         System.out.println("集合中的最小元素："+Collections.min(list));
 8         Collections.replaceAll(list,8,0);  //将集合中的8用0替换掉
 9         System.out.println("替换后的集合："+list);
10     }
11 }

运行结果：

集合中的元素：[-3, 2, 9, 5, 8]
集合中的最大元素：9集合中的最小元素：-3替换后的集合：[-3, 2, 9, 5, 0]

 

六、Arrays：用于操作数组的工具类。类中定义的都是静态工具方法。

1. 对数组排序。

2. 二分查找。

3. 数组复制。

4. 对两个数组进行元素的比较，判断两个数组是否相同。

5. 将数组转成字符串。

    1 //使用Arrays的sort()方法排序
    2 public class Example29 {
    3     public static void main(String[] args) {
    4         int[] arr={9,8,3,5,2};
    5         System.out.print("排序前：");
    6         printArray(arr);
    7         Arrays.sort(arr);
    8         System.out.print("排序后：");
    9         printArray(arr);
   10     }
   11     public static void printArray(int[] arr) {
   12         System.out.print("[");
   13         for (int x=0;x<arr.length;x++){
   14             if (x!=arr.length-1){
   15                 System.out.print(arr[x]+",");
   16             }else {
   17                 System.out.println(arr[x]+"]");
   18 
   19             }
   20         }
   21     }
   22 }

   排序前：[9,8,3,5,2]<br>排序后：[2,3,5,8,9]

    

6. 1 //使用Arrays的binarySearch（Object[] a,Object key）方法查找元素
   2 class Example {
   3     public void run() {
   4         int[] arr={9,8,3,5,2};
   5         Arrays.sort(arr);//调用排序方法，对数组排序
   6         int index = Arrays.binarySearch(arr,3);//查找指定元素3
   7         System.out.println("数组排序后元素3的索引是："+index);//输出打印元素所在的索引位置
   8     }
   9 }
   数组排序后元素3的索引是：1

    

7.  1 //使用Arrays的copyOfRange(int[] original,int from,int to)方法拷贝元素
    2 class Example31 {
    3     public void run() {
    4         int[] arr={9,8,3,5,2};
    5         int[] copies=Arrays.copyOfRange(arr,1,7);
    6         for (int i =0;i<arr.length;i++){
    7           System.out.print(copies[i]+",");
    8         }
    9     }
   10 }
   【8,3,5,2,0,0】

    1 //使用Arrays的fill（Object[] a,Object val）方法填充元素
    2 class Example{
    3     public void run() {
    4         int[] arr={1,2,3,4};
    5         Arrays.fill(arr,8);
    6         for (int i =0;i<arr.length;i++){
    7             System.out.print(i+":"+arr[i]+“---”);
    8         }
    9     }
   10 }
   0:8---1:8---2:8---3:8

   1 //使用Arrays的toString(int [] ,arr)方法把数组转换为字符串
   2 class Example{
   3     public void run() {
   4         int[] arr={9,8,3,5,2};
   5         String arrString=Arrays.toString(arr); //使用toString()方法将数组转换为字符串
   6             System.out.println(arrString);
   7     }
   8 }

     [9, 8, 3, 5, 2]

          6、数组转成list集合——asList() 。

             数组转成集合：就是为了使用集合的方法操作数组中的元素。

             但是不要使用增删等改变长度的方法。add remove 发生UnsupportedOperationException

             如果数组中存储的是基本数据类型，那么转成集合，数组对象会作为集合中的元素存在。数组中元素是引用数据类型时，转成，数组元素会作为集合元素存在。

           7、集合转成数组——toArray().

为什么集合转成数组呢？

为了限制对元素的增删操作。

如果传递的数组的长度小于集合的长度，会创建一个同类型的数组长度为集合的长度。

如果传递的数组的长度大于集合的长度，就会使用这个数组，没有存储元素的位置为null。

长度最好直接定义为何集合长度一致。

以上是Java之集合概述的詳細內容。更多資訊請關注PHP中文網其他相關文章！

本網站聲明

本文內容由網友自願投稿，版權歸原作者所有。本站不承擔相應的法律責任。如發現涉嫌抄襲或侵權的內容，請聯絡admin@php.cn

熱AI工具

Undresser.AI Undress

人工智慧驅動的應用程序，用於創建逼真的裸體照片

AI Clothes Remover

用於從照片中去除衣服的線上人工智慧工具。

Undress AI Tool

免費脫衣圖片

Clothoff.io

AI脫衣器

AI Hentai Generator

免費產生 AI 無盡。

顯示更多

熱門文章

R.E.P.O.能量晶體解釋及其做什麼（黃色晶體）

1 個月前 By 尊渡假赌尊渡假赌尊渡假赌

R.E.P.O.最佳圖形設置

1 個月前 By 尊渡假赌尊渡假赌尊渡假赌

刺客信條陰影：貝殼謎語解決方案

2 週前 By DDD

R.E.P.O.如果您聽不到任何人，如何修復音頻

1 個月前 By 尊渡假赌尊渡假赌尊渡假赌

R.E.P.O.聊天命令以及如何使用它們

1 個月前 By 尊渡假赌尊渡假赌尊渡假赌

顯示更多

熱工具

記事本++7.3.1

好用且免費的程式碼編輯器

SublimeText3漢化版

中文版，非常好用

禪工作室 13.0.1

強大的PHP整合開發環境

Dreamweaver CS6

視覺化網頁開發工具

SublimeText3 Mac版

神級程式碼編輯軟體(SublimeText3)

顯示更多

熱門話題

gmail信箱登陸入口在哪裡

7541

15

CakePHP 教程

1381

52

steam的賬戶名稱是什麼格式

83

11

win11激活密鑰永久

55

19

NYT連接提示和答案

21

86

顯示更多