一、Stream中間操作
Stream的中間操作是指在流鏈當中,可以對資料進行處理操作,包括filter過濾、map映射轉換、flatMap合併、distinct去重、sorted排序等操作。這些操作都會傳回一個新的Stream流對象,可以透過鍊式呼叫多個中間操作進行複雜的資料處理。需要注意的是,中間操作需要具有終止操作才會觸發。
下面以類別來講解Stream常見的中間操作。
1.1、filter:過濾出符合條件的元素
filter()方法常用於實現資料過濾,即可以對集合、陣列等資料來源篩選出符合指定條件的元素,並返回一個新的流。
假設有一個黑名單手機號碼列表,需要篩選出其中所有開頭為「133」的元素,那麼可以透過filter()實作——
//将数组转换为一个字符串列表 List<String> numbers = Arrays.asList("13378520000","13278520000","13178520000","13358520000"); //通过stream()方法创建一个流,接着使用filter()方法过滤出前缀为“133”的元素,最终通过collect() 方法将结果收集到一个新列表中 List<String> filterdNumbers = numbers.stream().filter(s -> s.startsWith("133")).collect(Collectors.toList()); System.out.println(filterdNumbers); //打印结果:[13378520000, 13358520000]
1.2、map:映射轉換元素
map()方法用於對流中的每個元素進行映射操作,將其轉換為另一個元素或提取其中的信息,並傳回一個新的流。
根據以下兩個案例分別學習map()將元素轉換為另一個元素以及提取元素其中的信息——
1.2.1、轉換元素
假設有一個手機號字元列表,需要根據前7位來確定手機號歸屬地,那麼就需要取得所有手機號前7位子字串,可以使用map()方法實現:
List<String> numbers = Arrays.asList("13378520000","13278520000","13178520000","13558520000"); //通过stream()方法创建一个流,使用map()方法将每个字符串转换为截取前7位的字符,最后使用collect()方法将结果收集到一个新列表中 List<String> filterdNumbers = numbers.stream().map(s -> s.substring(0,7)).collect(Collectors.toList()); System.out.println(filterdNumbers); //打印结果:[1337852, 1327852, 1317852, 1355852]
1.2.2、提取元素資訊
假設有一個使用者物件列表,我們需要提取其中每個物件的手機號,可以使用map()方法實作:
List<People> peopleList = Arrays.asList( new People("王二","13378520000"), new People("李二","13278520000"), new People("张四","13178520000") ); //通过stream()方法创建一个流,使用map()方法提取每个用户的手机号,最后使用collect()方法将结果收集到一个新列表中 List<String> tel = peopleList.stream().map(People::getTel).collect(Collectors.toList()); System.out.println(tel); //打印结果:[13378520000, 13278520000, 13178520000]
1.3、flatMap:將多個流合併為一個流
flatMap()方法可以實現多對多的映射,或者將多個列表合併成一個列表操作。
1.3.1、實現多對多的對應
假設有兩組餘額清單A和B,需要將A組每個元素都與B組所有元素依序進行相加,可以使用flatMap實作該多對多的映射——
List<Integer> listA = Arrays.asList(1, 2, 3); List<Integer> listB = Arrays.asList(4, 5, 6); List<Integer> list = listA.stream().flatMap(a -> listB.stream().map(b -> a +b)).collect(Collectors.toList()); System.out.println(list); //打印结果: [5, 6, 7, 6, 7, 8, 7, 8, 9]
1.3.2、將多個列表合併成一個列表
#假設有一個包含多個手機號字串列表的列表,現在需要合併所有手機號字串成為一個列表,可以使用flatMap()方法實現:
List<List<String>> listOfLists = Arrays.asList( Arrays.asList("13378520000", "13278520000"), Arrays.asList("13178520000", "13558520000"), Arrays.asList("15138510000", "15228310000") ); List<String> flatMapList = listOfLists.stream().flatMap(Collection::stream).collect(Collectors.toList()); System.out.println(flatMapList); //打印结果:[13378520000, 13278520000, 13178520000, 13558520000, 15138510000, 15228310000]
1.4、distinct:去除重複的元素
distinct()方法可以用來移除流中的重複元素,產生無重複的列表。
假設有一個包含重複手機號字串的列表,可以使用distinct()去重操作——
List<String> numbers = Arrays.asList("13378520000", "15138510000","13178520000", "15138510000"); List<String> disNumbers = numbers.stream().distinct().collect(Collectors.toList()); System.out.println(disNumbers); //打印结果:[13378520000, 15138510000, 13178520000]
注意一點的是,distinct用於針對流作去重操作時,需要確定流中元素實現了equals()和hashCode()方法,因為這兩個方法是判斷兩個物件是否相等的標準。
1.5、sorted:排序元素
sorted()方法用於對流中的元素進行排序。
假設需要對一組People物件依照年齡排序,以下分別依升序排序與降序排序——
1.5.1、升序排序
##預設情況下,是升序排序——People {name='李二', age=30}List<People> peopleList = Arrays.asList( new People("王二",20), new People("李二",30), new People("张四",31) ); List<People> newpeopleList=peopleList.stream().sorted(Comparator.comparing(People::getAge)).collect(Collectors.toList()); //打印结果 newpeopleList.stream().forEach(System.out::println);
列印結果:
People{name='王二', age=20}
People{name='張四', age=31}
###1.5.2、降序排序##### #####透過reversed()方法進行逆序排序,也就是將升序排序進行倒序排序——###List<People> peopleList = Arrays.asList( new People("王二",20), new People("李二",30), new People("张四",31) ); List<People> newpeopleList = peopleList.stream().sorted(Comparator.comparing(People::getAge).reversed()).collect(Collectors.toList()); //打印结果 newpeopleList.stream().forEach(System.out::println);###列印結果:########People{name='張四', age=31}###People{name='李二', age=30}###People{name='王二', age=20}#########1.6 、peek:查看每個元素的信息,但不修改流中元素的狀態######peek()方法用於查看流中的元素而不會修改流中元素的狀態,可以在流中的任何階段使用,不會影響到流的操作,也不會終止流的操作。 ###
List<String> telList = Arrays.asList("13378520000","13278520000","13178520000","13558520000"); telList.stream().peek(t -> System.out.println(t)) .map(t -> t.substring(0,3)) .peek(t -> System.out.println(t)) .collect(Collectors.toList());###列印結果:######### 13378520000### 132#########peek()方法和forEach很類似,都是可以用於遍歷流中的元素,但是,兩者之間存在著較大的差異。主要一點是,forEach在流中是一個終止操作,一旦調用它,就意味著Stream流已經被處理完成,不能再進行任何操作,例如,無法在forEach之後針對流進行map、filter等操作,但peek方法可以,以上的案例可以看出,在第一次呼叫peek列印一個元素後,該元素還可以接著進行map操作,進行字串的前三位截取。 ######這是peek()方法和forEach最大的差別。 ###
1.7、limit 和 skip:截取流中的部分元素
limit()和skip()都是用于截取Stream流中部分元素的方法,两者区别在于,limit()返回一个包含前n个元素的新流,skip()则返回一个丢弃前n个元素后剩余元素组成的新流。
int[] arr = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10}; System.out.print("取数组前5个元素:"); Arrays.stream(arr).limit(5).forEach(n -> System.out.print(n + " ")); // 输出结果为:1 2 3 4 5 System.out.print("跳过前3个元素,取剩余数组元素:"); Arrays.stream(arr).skip(3).forEach(n -> System.out.print(n + " ")); // 输出结果为:4 5 6 7 8 9 10
二、Stream终止操作
Stream的终止操作是指执行Stream流链中最后一个步骤,到这一步就会结束整个流处理。在Java8中,Stream终止操作包括forEach、toArray、reduce、collect、min、max、count、anyMatch、allMatch、noneMatch、findFirst和findAny等。这些终止操作都有返回值。需要注意一点是,如果没有执行终止操作的话,Stream流是不会触发执行的,例如,一个没有终止操作的peek()方法代码是不会执行进而打印——
list.stream().peek(t -> System.out.println("ddd"))
当加上终止操作话,例如加上collect,就会打印出“ddd”——
list.stream().peek(t -> System.out.println("ddd")).collect(Collectors.toList());
下面按类别分别讲解各个终止操作的使用。
2.1、forEach:遍历流中的每个元素
该forEach前面已经提到,这里不做过多介绍。
2.2、count:统计流中元素的数量
count可以统计流中元素的数量并返回结果。
假设有一个包含多个手机号字符串的列表,需要统计去重后的手机号数量,就可以使用count方法——
List<String> numbers = Arrays.asList("13378520000", "15138510000","13178520000", "15138510000"); long count = numbers.stream() .distinct()//去重 .count();//统计去重后的手机号 System.out.println(count); //打印结果:3
2.3、reduce:将流中的所有元素归约成一个结果
reduce()可以将流中的所有元素根据指定规则归约成一个结果,并将该结果返回。
常用语法格式如下:
Optional<T> result = stream.reduce(BinaryOperator<T> accumulator);
可见,reduce方法会返回一个Optional类型的值,表示归约后的结果,需要通过get()方法获取Optional里的值。
假设有一个包含多个手机号字符串的List列表,需要在去重之后,再将列表所有字符串拼按照逗号间隔接成一个字符串返回,那么就可以通过reduce来实现——
List<String> numbers = Arrays.asList("13378520000", "15138510000","13178520000", "15138510000"); Optional result = numbers.stream() .distinct() //去重 .reduce((a ,b) -> a+","+b);//指定规则为,相临两个字符通过逗号“,”间隔 System.out.println(result.get()); //打印结果:13378520000,15138510000,13178520000
2.4、collect:将流中的元素收集到一个容器中,并返回该容器
collect的作用是将流中的元素收集到一个新的容器中,返回该容器。打个比喻,它就像一个采摘水果的工人,负责将水果一个个采摘下来,然后放进一个篮子里,最后将篮子交给你。我在前面的案例当中,基本都有用到collect,例如前面2.1的filter过滤用法中的List filterdNumbers = numbers.stream().filter(s -> s.startsWith("133")).collect(Collectors.toList()),就是将过滤出前缀为“133”的字符串,将这些过滤处理后的元素交给collect这个终止操作。这时collect就像采摘水果的员工,把采摘为前缀“133”的“水果”通过toList()方法收集到一个新的List容器当中,然后交给你。最后你就可以得到一个只装着前缀为“133”的元素集合。
在Java8的collect方法中,除里toList()之外,还提供了例如toSet,toMap等方法满足不同的场景,根据名字就可以知道,toSet()返回的是一个Set集合,toMap()返回的是一个Map集合。
2.5、min 和 max:找出流中的最小值和最大值
min和max用来查找流中的最小值和最大值。
假设需要在查找出用户列表中年龄最小的用户,可以按照以下代码实现——
List<People> peopleList = Arrays.asList( new People("王二",20), new People("李二",30), new People("张四",31) ); //查找年龄最小的用户,若没有则返回一个null People people = peopleList.stream().min(Comparator.comparing(People::getAge)).orElse(null); System.out.println(people); //打印结果:People{name='王二', age=20}
max的用法类似,这里不做额外说明。
2.6、anyMatch、allMatch 和 noneMatch:判断流中是否存在满足指定条件的元素
2.6.1、anyMatch
anyMatch用于判断,如果流中至少有一个元素满足给定条件,那么返回true,反之返回false,即 true||false为true这类的判断。
假设在一个手机号字符串的List列表当中,判断是否包含前缀为“153”的手机号,就可以使用anyMatch——
List<String> numbers = Arrays.asList("13378520000", "15138510000","13178520000", "15338510000"); boolean hasNum = numbers.stream().anyMatch(n -> n.startsWith("153")); System.out.println(hasNum); //打印结果:true
2.6.2、allMatch
allMatch用于判断,流中的所有元素是否都满足给定条件,满足返回true,反之false,即true&&false为false这类判断。
假设在一个手机号字符串的List列表当中,判断手机号是否都满足前缀为“153”的手机号,就可以用allMatch——
List<String> numbers = Arrays.asList("13378520000", "15138510000","13178520000", "15338510000"); boolean hasNum = numbers.stream().allMatch(n -> n.startsWith("153")); System.out.println(hasNum); //打印结果:false
2.6.3、noneMatch
noneMatch用于判断,如果流中没有任何元素满足给定的条件,返回true,如果流中有任意一个条件满足给定条件,返回false,类似!true为false的判断。
假设在一个手机号字符串的List列表当中,判断手机号是否都不满足前缀为“153”的手机号,就可以用noneMatch——
List<String> numbers = Arrays.asList("13378520000", "15138510000","13178520000", "1238510000"); //numbers里没有前缀为“153”的手机号 boolean hasNum = numbers.stream().noneMatch(n -> n.startsWith("153")); System.out.println(hasNum); //打印结果:true
这三个方法其实存在一定互相替代性,例如在3.6.1中,满足!anyMatch表示所有手机号都不为“153”前缀,才得到true,这不就是noneMatch,主要看在项目当中如何灵活应用。
2.7、findFirst 和 findAny:返回流中第一个或任意一个元素
2.7.1、findFirst
findFirst用于返回流中第一个元素,如果流为空话,则返回一个空的Optional对象——
假设需要对一批同手机号的黑名单用户按照时间戳降序排序,然后取出第一个即时间戳为最早的用户,就可以使用findFirst——
List<People> peopleList = Arrays.asList( new People("王二","13178520000","20210409"), new People("李二","13178520000","20230401"), new People("张四","13178520000","20220509"), new People("赵六","13178520000","20220109") ); /** * 先按照时间升序排序,排序后的结果如下: * People{name='王二', tel='13178520000', time='20210409'} * People{name='赵六', tel='13178520000', time='20220109'} * People{name='张四', tel='13178520000', time='20220509'} * People{name='李二', tel='13178520000', time='20230401'} * *排序后,People{name='王二', tel='13178520000', time='20210409'}成了流中的第一个元素 */ People people = peopleList.stream().sorted(Comparator.comparing(People::getTime)).findFirst().orElse(null); System.out.println(people); //打印结果:People{name='王二', tel='13178520000', time='20210409'}
2.7.2、findAny
findAny返回流中的任意一个元素,如果流为空,则通过Optional对象返回一个null。
假设有一个已经存在的黑名单手机号列表blackList,现在有一批新的手机号列表phoneNumber,需要基于blackList列表过滤出phoneNumber存在的黑名单手机号,最后从过滤出来的黑名单手机号当中挑选出来出来任意一个,即可以通过findAny实现——
//blackList是已经存在的黑名单列表 List<String> blackList = Arrays.asList("13378520000", "15138510000"); //新来的手机号列表 List<String> phoneNumber = Arrays.asList("13378520000", "13178520000", "1238510000","15138510000","13299920000"); String blackPhone = phoneNumber.stream() //过滤出phoneNumber有包含在blackList的手机号,这类手机号即为黑名单手机号。 .filter(phone -> blackList.contains(phone)) //获取过滤确定为黑名单手机号的任意一个 .findAny() //如果没有则返回一个null .orElse(null); System.out.println(blackPhone); //打印结果:13378520000
三、并行流
前面的案例主要都是以顺序流来讲解,接下来,就是讲解Stream的并行流。在大数据量处理场景下,使用并行流可以提高某些操作效率,但同样存在一些需要考虑的问题,并非所有情况下都可以使用。
3.1、什么是并行流:并行流的概念和原理
并行流是指通过将数据按照一定的方式划分成多个片段分别在多个处理器上并行执行,这就意味着,可能处理完成的数据顺序与原先排序好的数据情况是不一致的。主要是用在比较大的数据量处理情况,若数据量太少,效率并不比顺序流要高,因为底层其实就使用到了多线程的技术。
并行流的流程原理如下:
1、输入数据:并行流的初始数据一般是集合或者数组,例如Arrays.asList("13378520000", "13178520000", "1238510000","15138510000","13299920000");
2、划分数据:将初始数据平均分成若干个子集,每个子集可以在不同的线程中独立进行处理,这个过程通常叫“分支”(Forking),默认情况下,Java8并行流使用到了ForkJoinPool框架,会将Arrays.asList("13378520000", "13178520000", "1238510000","15138510000","13299920000")划分成更小的颗粒进行处理,可能会将该数组划分成以下三个子集:
[13378520000, 13178520000] [1238510000, 13338510000] [13299920000]
3、处理数据:针对划分好的子集并行进行相同的操作,例如包括过滤(filter)、映射(map)、去重(distinct)等,这个过程通常叫“计算”(Computing),例如需要过滤为前缀包括“133”的字符集合,那么,各个子集,就会处理得到以下结果:
[13378520000] [13338510000] []
4、合并结果:将所有子集处理完成的结果进行汇总,得到最终结果。这个过程通常叫“合并”(Merging),结果就会合并如下:
[13378520000,13338510000]
5、返回结果:返回最终结果。
通俗而言,就是顺序流中,只有一个工人在摘水果,并行流中,是多个工人同时在摘水果。
3.2、创建并行流:通过 parallel() 方法将串行流转换为并行流
可以通过parallel()方法将顺序流转换为并行流,操作很简单,只需要在顺序流上调用parallel()即可。
List<String> numbers = Arrays.asList("13378360000","13278240000","13178590000","13558120000"); //通过stream().parallel()方法创建一个并行流,使用map()方法将每个字符串转换为截取前7位的字符,最后使用collect()方法将结果收集到一个新列表中 List<String> filNums = numbers.stream().parallel().map(s -> s.substring(0,7)).collect(Collectors.toList()); System.out.println(filNums); //打印结果:[1337836, 1327824, 1317859, 1355812]
3.3、并行流的注意事项:并行流可能引发的线程安全,以及如何避免这些问题
在使用并发流的过程中,可能会引发以下线程安全问题:并行流中的每个子集都在不同线程运行,可能会导致对共享状态的竞争和冲突。
避免线程问题的方法如下:避免修改共享状态,即在处理集合过程当中,避免被其他线程修改集合数据,可以使用锁来保证线程安全。
使用无状态操作:在并行流处理过程尽量使用无状态操作,例如filter、map之类的,可以尽量避免线程安全和同步问题。
四、Optional
4.1、什么是 Optional:Optional 类型的作用和使用场景
在实际开发当中,Optional类型通常用于返回可能为空的方法、避免null值的传递和简化复杂的判断逻辑等场景。调用Optional对象的方法,需要通过isPresent()方法判断值是否存在,如果存在则可以通过get()方法获取其值,如果不存在则可以通过orElse()方法提供默认值,或者抛出自定义异常处理。
4.2、如何使用 Optional:如何使用 Optional 类型
使用Optional类型主要目的是在数据可能为空的情况下,提供一种更安全、更优雅的处理方式。
以下是使用Optional类型的常用方法:
4.2.1、ofNullable()和isPresent()方法
将一个可能为null的对象包装成Optional类型的对象,然后根据isPresent方法判断对象是否包含空值——
String str = null; Optional<String> optStr = Optional.ofNullable(str); if (optStr.isPresent()){ System.out.println("Optional对象不为空"); }else { System.out.println("Optional对象为空"); } //打印结果:Optional对象为空
4.2.2、get()方法
获取Optional对象中的值,如果对象为空则抛出NoSuchElementException异常——
String str = null; Optional<String> optStr = Optional.ofNullable(str); if (optStr.isPresent()){ System.out.println("Optional对象不为空"); }else { System.out.println("Optional对象为空"); optStr.get(); }
控制台打印结果:
Exception in thread "main" java.util.NoSuchElementException: No value present
at java.util.Optional.get(Optional.java:135)
at com.zhu.fte.biz.test.StreamTest.main(StreamTest.java:144)
Optional对象为空
4.2.4、orElse()方法
获取Optional对象中的值,如果对象为空则返回指定的默认值——
String str = null; Optional<String> optStr = Optional.ofNullable(str); if (optStr.isPresent()){ System.out.println("Optional对象不为空"); }else { System.out.println("Optional对象为空,返回默认值:" + optStr.orElse("null")); } //打印结果:Optional对象为空,返回默认值:null
当然,如果不为空的话,则能正常获取对象中的值——
String str = "测试"; Optional<String> optStr = Optional.ofNullable(str); if (optStr.isPresent()){ System.out.println("Optional对象不为空,返回值:" + optStr.orElse("null")); }else { System.out.println("Optional对象为空,返回默认值:" + optStr.orElse("null")); } //打印结果:Optional对象不为空,返回值:测试
那么,问题来了,它是否能判断“ ”这类空格的字符串呢,我实验了一下,
String str = " "; Optional<String> optStr = Optional.ofNullable(str); if (optStr.isPresent()){ System.out.println("Optional对象不为空,返回值:" + optStr.orElse("null")); }else { System.out.println("Optional对象为空,返回默认值:" + optStr.orElse("null")); } //打印结果:Optional对象不为空,返回值:
可见,这类空字符串,在orElse判断当中,跟StringUtils.isEmpty()类似,都是把它当成非空字符串,但是StringUtils.isBlank()则判断为空字符串。
4.2.5、orElseGet()方法
orElseGet()和orElse()类似,都可以提供一个默认值。两者区别在于,orElse方法在每次调用时都会创建默认值,而orElseGet只在需要时才会创建默认值。
4.3、Optional 和 null 的区别: Optional 类型与 null 值的异同
两者都可以表示缺失值的情况,两者主要区别为:Optional类型是一种包装器对象,可以将一个可能为空的对象包装成一个Optional对象。这个对象可以通过调用ofNullable()
、of()
或其他方法来创建。而null值则只是一个空引用,没有任何实际的值。
Optional类型还可以避免出现NullPointerException异常,具体代码案例如下:
String str = null; //错误示范:直接调用str.length()方法会触发NullPointerException //int length = str.length() //通过Optional类型避免NullPointerException Optional<String> optionalStr = Optional.ofNullable(str); if (optionalStr.isPresent()){//判断Optional对象是否都包含非空值 int length = optionalStr.get().length(); System.out.println("字符串长度为:" + length); }else { System.out.println("字符串为空!"); } //使用map()方法对Optional对象进行转换时,确保返回对结果不为null Optional<Integer> optionalLength = optionalStr.map(s -> s.length()); System.out.println("字符串长度为:" + optionalLength.orElse(-1)); // 使用orElse()方法提供默认值
五、扩展流处理
除里以上常用的流处理之外,Java8还新增了一些专门用来处理基本类型的流,例如IntStream、LongStream、DoubleStream等,其对应的Api接口基本与前面案例相似,读者可以自行研究。
最后,需要注意一点是,在流处理过程当中,尽量使用原始类型数据,避免装箱操作,因为装箱过程会有性能开销、内存占用等问题,例如,当原始数据int类型被装箱成Integer包装类型时,这个过程会涉及到对象的创建、初始化、垃圾回收等过程,需要额外的性能开销。
以上是Java8中如何使用Stream串流程式設計的詳細內容。更多資訊請關注PHP中文網其他相關文章!

本篇文章给大家带来了关于java的相关知识,其中主要介绍了关于结构化数据处理开源库SPL的相关问题,下面就一起来看一下java下理想的结构化数据处理类库,希望对大家有帮助。

本篇文章给大家带来了关于java的相关知识,其中主要介绍了关于PriorityQueue优先级队列的相关知识,Java集合框架中提供了PriorityQueue和PriorityBlockingQueue两种类型的优先级队列,PriorityQueue是线程不安全的,PriorityBlockingQueue是线程安全的,下面一起来看一下,希望对大家有帮助。

本篇文章给大家带来了关于java的相关知识,其中主要介绍了关于java锁的相关问题,包括了独占锁、悲观锁、乐观锁、共享锁等等内容,下面一起来看一下,希望对大家有帮助。

本篇文章给大家带来了关于java的相关知识,其中主要介绍了关于多线程的相关问题,包括了线程安装、线程加锁与线程不安全的原因、线程安全的标准类等等内容,希望对大家有帮助。

本篇文章给大家带来了关于Java的相关知识,其中主要介绍了关于关键字中this和super的相关问题,以及他们的一些区别,下面一起来看一下,希望对大家有帮助。

本篇文章给大家带来了关于java的相关知识,其中主要介绍了关于枚举的相关问题,包括了枚举的基本操作、集合类对枚举的支持等等内容,下面一起来看一下,希望对大家有帮助。

封装是一种信息隐藏技术,是指一种将抽象性函式接口的实现细节部分包装、隐藏起来的方法;封装可以被认为是一个保护屏障,防止指定类的代码和数据被外部类定义的代码随机访问。封装可以通过关键字private,protected和public实现。

本篇文章给大家带来了关于java的相关知识,其中主要介绍了关于设计模式的相关问题,主要将装饰器模式的相关内容,指在不改变现有对象结构的情况下,动态地给该对象增加一些职责的模式,希望对大家有帮助。


熱AI工具

Undresser.AI Undress
人工智慧驅動的應用程序,用於創建逼真的裸體照片

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

Undress AI Tool
免費脫衣圖片

Clothoff.io
AI脫衣器

AI Hentai Generator
免費產生 AI 無盡。

熱門文章

熱工具

ZendStudio 13.5.1 Mac
強大的PHP整合開發環境

SAP NetWeaver Server Adapter for Eclipse
將Eclipse與SAP NetWeaver應用伺服器整合。

EditPlus 中文破解版
體積小,語法高亮,不支援程式碼提示功能

DVWA
Damn Vulnerable Web App (DVWA) 是一個PHP/MySQL的Web應用程序,非常容易受到攻擊。它的主要目標是成為安全專業人員在合法環境中測試自己的技能和工具的輔助工具,幫助Web開發人員更好地理解保護網路應用程式的過程,並幫助教師/學生在課堂環境中教授/學習Web應用程式安全性。 DVWA的目標是透過簡單直接的介面練習一些最常見的Web漏洞,難度各不相同。請注意,該軟體中

Atom編輯器mac版下載
最受歡迎的的開源編輯器