首页 > 其他分享 >JDK8的stream流的常用操作

JDK8的stream流的常用操作

时间:2023-01-12 16:13:51浏览次数:39  
标签:常用 stream Stream System JDK8 println new public

stream流介绍

集合处理数据的弊端

当我们需要对集合中的元素进行操作的时候,除了必需的添加、删除、获取外,最典型的就是集合遍历。我们来体验集合操作数据的弊端,需求如下:
传统写法,代码如下:

public class Demo {
    public static void main(String[] args) {
        // 一个ArrayList集合中存储有以下数据:张无忌,周芷若,赵敏,张强,张三丰
        // 需求:1.拿到所有姓张的 2.拿到名字长度为3个字的 3.打印这些数据
        ArrayList<String> list = new ArrayList<>();
        Collections.addAll(list, "张无忌", "周芷若", "赵敏", "张强", "张三丰");
        // 1.拿到所有姓张的
        ArrayList<String> zhangList = new ArrayList<>(); // {"张无忌", "张强", "张三丰"}
        for (String name : list) {
            if (name.startsWith("张")) {
                zhangList.add(name);
            }
        }
        // 2.拿到名字长度为3个字的
        ArrayList<String> threeList = new ArrayList<>(); // {"张无忌", "张三丰"}
        for (String name : zhangList) {
            if (name.length() == 3) {
                threeList.add(name);
            }
        }
        // 3.打印这些数据
        for (String name : threeList) {
            System.out.println(name);
        }
    }
}

这段代码中含有三个循环,每一个作用不同:

  1. 首先筛选所有姓张的人;
  2. 然后筛选名字有三个字的人;
  3. 最后进行对结果进行打印输出。
    每当我们需要对集合中的元素进行操作的时候,总是需要进行循环、循环、再循环。这是理所当然的么?不是。循环是做事情的方式,而不是目的。每个需求都要循环一次,还要搞一个新集合来装数据,如果希望再次遍历,只能再使用另一个循环从头开始。
    那Stream能给我们带来怎样更加优雅的写法呢?Stream的更优写法
public class Demo {
    public static void main(String[] args) {
        // 一个ArrayList集合中存储有以下数据:张无忌,周芷若,赵敏,张强,张三丰
        ArrayList<String> list = new ArrayList<>();
        Collections.addAll(list, "张无忌", "周芷若", "赵敏", "张强", "张三丰");
        // 1.拿到所有姓张的 2.拿到名字长度为3个字的 3.打印这些数据
        list.stream().filter(s -> s.startsWith("张")).filter(s -> s.length() == 3).forEach(System.out::println);
    }
}

直接阅读代码的字面意思即可完美展示无关逻辑方式的语义:获取流、过滤姓张、过滤长度为3、逐一打印。我们真正要做的事情内容被更好地体现在代码中。

Stream流式思想概述

注意:Stream和IO流(InputStream/OutputStream)没有任何关系,请暂时忘记对传统IO流的固有印象!
Stream流式思想类似于工厂车间的“生产流水线”,Stream流不是一种数据结构,不保存数据,而是对数据进行加工处理。Stream可以看作是流水线上的一个工序。在流水线上,通过多个工序让一个原材料加工成一个商品。

获取Stream流的两种方式

获取一个流非常简单,有以下几种常用的方式:

  1. 所有的 Collection 集合都可以通过 stream 默认方法获取流;
  2. Stream 接口的静态方法 of 可以获取数组对应的流;

根据Collection获取流

首先, java.util.Collection 接口中加入了default方法 stream 用来获取流,所以其所有实现类均可获取流。

public interface Collection<E> extends Iterable<E> {
	default Stream<E> stream() {
		return StreamSupport.stream(spliterator(), false);
	}
}
public class Demo {
    public static void main(String[] args) {
        // 方式1 : 根据Collection获取流
        List<String> list = new ArrayList<>();
        Stream<String> stream1 = list.stream();
        Set<String> set = new HashSet<>();
        Stream<String> stream2 = set.stream();
        Map<String, String> map = new HashMap<>();
        Stream<String> stream3 = map.keySet().stream();
        Stream<String> stream4 = map.values().stream();
        Stream<Map.Entry<String, String>> stream5 = map.entrySet().stream();
    }
}

Stream中的静态方法of获取流

由于数组对象不可能添加默认方法,所以 Stream 接口中提供了静态方法 of。

public interface Stream<T> extends BaseStream<T, Stream<T>> {
	public static<T> Stream<T> of(T t) {
		return StreamSupport.stream(new Streams.StreamBuilderImpl<>(t), false);
	}
	public static<T> Stream<T> of(T... values) {
		return Arrays.stream(values);
	}
}
public class Demo {
    public static void main(String[] args) {
        // 方式2 : Stream中的静态方法of获取流
        Stream<String> stream6 = Stream.of("aa", "bb", "cc");
        String[] strs = {"aa", "bb", "cc"};
        Stream<String> stream7 = Stream.of(strs);
        // 基本数据类型的数组行不行?不行的,会将整个数组看做一个元素进行操作.
        int[] arr = {11, 22, 33};
        Stream<int[]> stream8 = Stream.of(arr);
    }
}

Stream常用方法和注意事项

Stream流模型的操作很丰富,这里介绍一些常用的API。这些方法可以被分成两种:
image
终结方法:返回值类型不再是 Stream 类型的方法,不再支持链式调用。本小节中,终结方法包括count 和 forEach 方法。
非终结方法:返回值类型仍然是 Stream 类型的方法,支持链式调用。(除了终结方法外,其余方法均为非终结方法。)

Stream注意事项(重要)

  1. Stream只能操作一次
  2. Stream方法返回的是新的流
  3. Stream不调用终结方法,中间的操作不会执行

Stream流的forEach方法

forEach 用来遍历流中的数据

void forEach(Consumer<? super T> action);

该方法接收一个 Consumer 接口函数,会将每一个流元素交给该函数进行处理。例如:

public class Demo {
    public static void main(String[] args) {
        List<String> one = new ArrayList<>();
        Collections.addAll(one, "宋远桥", "苏星河", "老子", "庄子", "孙子");
        // 调用流中的方法
        /*one.stream().forEach((String str) -> {
            System.out.println(str);
        });*/
        // Lambda可以省略
        /*one.stream().forEach(str -> System.out.println(str));*/
        // Lambda可以转成方法引用
        one.stream().forEach(System.out::println);
    }
}

Stream流的count方法

Stream流提供 count 方法来统计其中的元素个数:

long count();

该方法返回一个long值代表元素个数。基本使用:

public class Demo {
    public static void main(String[] args) {
        List<String> one = new ArrayList<>();
        Collections.addAll(one, "宋远桥", "苏星河", "老子", "庄子", "孙子");
        long count = one.stream().count();
        System.out.println(count);
    }
}

Stream流的filter方法

filter用于过滤数据,返回符合过滤条件的数据。可以通过 filter 方法将一个流转换成另一个子集流。方法声明:

Stream<T> filter(Predicate<? super T> predicate);

该接口接收一个 Predicate 函数式接口参数(可以是一个Lambda或方法引用)作为筛选条件。
Stream流中的 filter 方法基本使用的代码如:

public class Demo {
    public static void main(String[] args) {
        List<String> one = new ArrayList<>();
        Collections.addAll(one, "宋远桥", "苏星河", "老子", "庄子", "孙子");
        one.stream().filter(s -> s.length() == 3).forEach(System.out::println);
    }
}

Stream流的limit方法

imit 方法可以对流进行截取,只取用前n个。方法签名:

Stream<T> limit(long maxSize);

参数是一个long型,如果集合当前长度大于参数则进行截取。否则不进行操作。基本使用:

public class Demo {
    public static void main(String[] args) {
        List<String> one = new ArrayList<>();
        Collections.addAll(one, "宋远桥", "苏星河", "老子", "庄子", "孙子");
        one.stream().limit(3).forEach(System.out::println);
    }
}

Stream流的skip方法

如果希望跳过前几个元素,可以使用 skip 方法获取一个截取之后的新流:

Stream<T> skip(long n);

如果流的当前长度大于n,则跳过前n个;否则将会得到一个长度为0的空流。基本使用:

public class Demo {
    public static void main(String[] args) {
        List<String> one = new ArrayList<>();
        Collections.addAll(one, "宋远桥", "苏星河", "老子", "庄子", "孙子");
        one.stream().skip(2).forEach(System.out::println);
    }
}

Stream流的map方法

如果需要将流中的元素映射到另一个流中,可以使用 map 方法。方法签名:

<R> Stream<R> map(Function<? super T, ? extends R> mapper);

该接口需要一个 Function 函数式接口参数,可以将当前流中的T类型数据转换为另一种R类型的流。
Stream流中的 map 方法基本使用的代码如:

public class Demo {
    public static void main(String[] args) {
        Stream<String> original = Stream.of("11", "22", "33");
        // Map可以将一种类型的流转换成另一种类型的流
        // 将Stream流中的字符串转成Integer
        /*Stream<Integer> stream = original.map((String s) -> {
            return Integer.parseInt(s);
        });*/
        // original.map(s -> Integer.parseInt(s)).forEach(System.out::println);
        original.map(Integer::parseInt).forEach(System.out::println);
    }
}

Stream流的sorted方法

如果需要将数据排序,可以使用 sorted 方法。方法签名:

Stream<T> sorted();
Stream<T> sorted(Comparator<? super T> comparator);

Stream流中的 sorted 方法基本使用的代码如:

public class Demo {
    public static void main(String[] args) {
        // sorted(): 根据元素的自然顺序排序
        // sorted(Comparator<? super T> comparator): 根据比较器指定的规则排序
        Stream<Integer> stream = Stream.of(33, 22, 11, 55);
        //stream.sorted().forEach(System.out::println);
        /*stream.sorted((Integer i1, Integer i2) -> {
            return i2 - i1;
        }).forEach(System.out::println);*/
        stream.sorted((i1, i2) -> i2 - i1).forEach(System.out::println);
    }
}

Stream流的distinct方法

如果需要去除重复数据,可以使用 distinct 方法。方法签名:

Stream<T> distinct();

Stream流中的 distinct 方法基本使用的代码如:

public class Demo {
    public static void main(String[] args) {
        Stream<Integer> stream = Stream.of(22, 33, 22, 11, 33);
        stream.distinct().forEach(System.out::println);
        Stream<String> stream1 = Stream.of("aa", "bb", "aa", "bb", "cc");
        stream1.distinct().forEach(System.out::println);
    }
}

注意:自定义类型是根据对象的hashCode和equals来去除重复元素的。

Stream流的match方法

如果需要判断数据是否匹配指定的条件,可以使用 Match 相关方法。方法签名:

boolean allMatch(Predicate<? super T> predicate);
boolean anyMatch(Predicate<? super T> predicate);
boolean noneMatch(Predicate<? super T> predicate);

Stream流中的 Match 相关方法基本使用的代码如:

public class Demo {
    public static void main(String[] args) {
        Stream<Integer> stream = Stream.of(5, 3, 6, 1);
        // boolean b = stream.allMatch(i -> i > 0); // allMatch: 匹配所有元素,所有元素都需要满足条件
        // boolean b = stream.anyMatch(i -> i > 5); // anyMatch: 匹配某个元素,只要有其中一个元素满足条件即可
        boolean b = stream.noneMatch(i -> i < 0); // noneMatch: 匹配所有元素,所有元素都不满足条件
        System.out.println(b);
    }
}

Stream流的find方法

如果需要找到某些数据,可以使用 find 相关方法。方法签名:

Optional<T> findFirst();
Optional<T> findAny();

Stream流中的 find 相关方法基本使用的代码如:

public class Demo {
    public static void main(String[] args) {
        Stream<Integer> stream = Stream.of(33, 11, 22, 5);
        // Optional<Integer> result = stream.findFirst();
        Optional<Integer> result = stream.findAny();
        System.out.println(result.get());
    }
}

Stream流的max和min方法

如果需要获取最大和最小值,可以使用 max 和 min 方法。方法签名:

Optional<T> min(Comparator<? super T> comparator);
Optional<T> max(Comparator<? super T> comparator);

Stream流中的 max 和 min 相关方法基本使用的代码如:

public class Demo {
    public static void main(String[] args) {
        Optional<Integer> max = Stream.of(5, 3, 6, 1).max((o1, o2) -> o1 - o2);
        System.out.println("最大值: " + max.get());
        Optional<Integer> min = Stream.of(5, 3, 6, 1).min((o1, o2) -> o1 - o2);
        System.out.println("最小值: " + min.get());
    }
}

Stream流的reduce方法

如果需要将所有数据归纳得到一个数据,可以使用 reduce 方法。方法签名:

T reduce(T identity, BinaryOperator<T> accumulator);
Optional<T> reduce(BinaryOperator<T> accumulator);
<U> U reduce(U identity,BiFunction<U, ? super T, U> accumulator,BinaryOperator<U> combiner);

Stream流中的 reduce 相关方法基本使用的代码如:

public class Demo {
    public static void main(String[] args) {
        // T reduce(T identity, BinaryOperator<T> accumulator);
        // T identity: 默认值
        // BinaryOperator<T> accumulator: 对数据进行处理的方式
        // reduce如何执行?
        // 第一次, 将默认值赋值给x, 取出集合第一元素赋值给y
        // 第二次, 将上一次返回的结果赋值x, 取出集合第二元素赋值给y
        // 第三次, 将上一次返回的结果赋值x, 取出集合第三元素赋值给y
        // 第四次, 将上一次返回的结果赋值x, 取出集合第四元素赋值给y
        int reduce = Stream.of(4, 5, 3, 9).reduce(0, (x, y) -> {
            System.out.println("x = " + x + ", y = " + y);
            return x + y;
        });
        System.out.println("reduce = " + reduce); // 21
        // 获取最大值
        Integer max = Stream.of(4, 5, 3, 9).reduce(0, (x, y) -> {
            return x > y ? x : y;
        });
        System.out.println("max = " + max);
    }
}

程序运行结果:
image

Stream流的map和reduce组合使用

public class Person {
    private String name;
    private int age;
	...
}

public class Demo {
    public static void main(String[] args) {
        // 求出所有年龄的总和
        // 1.得到所有的年龄
        // 2.让年龄相加
        Integer totalAge = Stream.of(
                new Person("张三", 58),
                new Person("李四", 56),
                new Person("王五", 54),
                new Person("赵六", 52))
                .map((p) -> p.getAge()).reduce(0, Integer::sum);
        System.out.println("totalAge = " + totalAge);
        // 找出最大年龄
        // 1.得到所有的年龄
        // 2.获取最大的年龄
        Integer maxAge = Stream.of(
                new Person("张三", 58),
                new Person("李四", 56),
                new Person("王五", 54),
                new Person("赵六", 52))
                .map(p -> p.getAge())
                .reduce(0, Math::max);
        System.out.println("maxAge = " + maxAge);
        // 统计 a 出现的次数
        // 1 0 0 1 0 1
        Integer count = Stream.of("a", "c", "b", "a", "b", "a")
                .map(s -> {
                    if (s == "a") {
                        return 1;
                    } else {
                        return 0;
                    }
                })
                .reduce(0, Integer::sum);
        System.out.println("count = " + count);
    }
}

Stream流的mapToInt方法

如果需要将Stream中的Integer类型数据转成int类型,可以使用 mapToInt 方法。方法签名:

IntStream mapToInt(ToIntFunction<? super T> mapper);

Stream流中的 mapToInt 相关方法基本使用的代码如:

public class Demo {
    public static void main(String[] args) {
        // Integer占用的内存比int多,在Stream流操作中会自动装箱和拆箱
        Stream<Integer> stream = Stream.of(1, 2, 3, 4, 5);
        // 把大于3的打印出来
        stream.filter(n -> n > 3).forEach(System.out::println);
        // IntStream: 内部操作的是int类型的数据,就可以节省内存,减少自动装箱和拆箱
        /*IntStream intStream = Stream.of(1, 2, 3, 4, 5).mapToInt((Integer n) -> {
            return n.intValue();
        });*/
        IntStream intStream = Stream.of(1, 2, 3, 4, 5).mapToInt(Integer::intValue);
        intStream.filter(n -> n > 3).forEach(System.out::println);
    }
}

Stream流的concat方法

如果有两个流,希望合并成为一个流,那么可以使用 Stream 接口的静态方法 concat :

public static <T> Stream<T> concat(Stream<? extends T> a, Stream<? extends T> b) {
	Objects.requireNonNull(a);
	Objects.requireNonNull(b);

	@SuppressWarnings("unchecked")
	Spliterator<T> split = new Streams.ConcatSpliterator.OfRef<>(
		(Spliterator<T>) a.spliterator(), (Spliterator<T>) b.spliterator());
	Stream<T> stream = StreamSupport.stream(split, a.isParallel() || b.isParallel());
	return stream.onClose(Streams.composedClose(a, b));
}

备注:这是一个静态方法,与 java.lang.String 当中的 concat 方法是不同的。
该方法的基本使用代码如:

public class Demo {
    public static void main(String[] args) {
        Stream<String> streamA = Stream.of("张三");
        Stream<String> streamB = Stream.of("李四");
        // 合并成一个流
        Stream<String> newStream = Stream.concat(streamA, streamB);
        // 注意:合并流之后,不能操作之前的流啦.
        // streamA.forEach(System.out::println);
        newStream.forEach(System.out::println);
    }
}

Stream综合案例

public class Demo {
    public static void main(String[] args) {
        // 第一个队伍
        List<String> one = Arrays.asList("千山暮雪", "宋远桥", "苏星河", "老子", "庄子","孙子", "洪七公");
        // 第二个队伍
        List<String> two = Arrays.asList("红叶先生", "张无忌", "张三丰", "赵丽颖", "张二狗", "张天爱", "张三");
        // 1.第一个队伍只要名字为3个字的成员姓名;
        // 2.第一个队伍筛选之后只要前3个人;
        Stream<String> streamA = one.stream().filter(s -> s.length() == 3).limit(3);
        // 3.第二个队伍只要姓张的成员姓名;
        // 4.第二个队伍筛选之后不要前2个人;
        Stream<String> streamB = two.stream().filter(s -> s.startsWith("张")).skip(2);
        // 5.将两个队伍合并为一个队伍;
        Stream<String> streamAB = Stream.concat(streamA, streamB);
        // 6.根据姓名创建`Person`对象;
        // 7.打印整个队伍的Person对象信息。
        streamAB.map(Person::new).forEach(System.out::println);
    }
}

收集Stream流中的结果

对流操作完成之后,如果需要将流的结果保存到数组或集合中,可以收集流中的数据

Stream流中的结果到集合中

Stream流提供 collect 方法,其参数需要一个 java.util.stream.Collector<T,A, R> 接口对象来指定收集到哪种集合中。java.util.stream.Collectors 类提供一些方法,可以作为 Collector 接口的实例:

<R> R collect(Supplier<R> supplier, BiConsumer<R, ? super T> accumulator, BiConsumer<R, R> combiner);
<R, A> R collect(Collector<? super T, A, R> collector);
public static <T> Collector<T, ?, List<T>> toList()
public static <T> Collector<T, ?, Set<T>> toSet()
public class Demo {
    public static void main(String[] args) {
        Stream<String> stream1 = Stream.of("aa", "bb", "cc", "bb");
        List<String> list = stream1.collect(Collectors.toList());
        System.out.println("list = " + list);

        Stream<String> stream2 = Stream.of("aa", "bb", "cc", "bb");
        Set<String> set = stream2.collect(Collectors.toSet());
        System.out.println("set = " + set);

        Stream<String> stream3 = Stream.of("aa", "bb", "cc", "bb");
        ArrayList<String> arrayList = stream3.collect(Collectors.toCollection(ArrayList::new));
        System.out.println("arrayList = " + arrayList);

        Stream<String> stream4 = Stream.of("aa", "bb", "cc", "bb");
        HashSet<String> hashSet = stream4.collect(Collectors.toCollection(HashSet::new));
        System.out.println("hashSet = " + hashSet);
    }
}

Stream流中的结果到数组中

Stream提供 toArray 方法来将结果放到一个数组中,返回值类型是Object[]的:

Object[] toArray();
<A> A[] toArray(IntFunction<A[]> generator);
public class Demo {
    public static void main(String[] args) {
        Stream<String> stream1 = Stream.of("aa", "bb", "cc");
        Object[] objects = stream1.toArray();
        for (Object o : objects) {
            System.out.println("o = " + o);
        }

        Stream<String> stream2 = Stream.of("aa", "bb", "cc");
        String[] strings = stream2.toArray(String[]::new);
        for (String string : strings) {
            System.out.println("string = " + string + ", 长度: " + string.length());
        }
    }
}

对流中数据进行聚合计算

当我们使用Stream流处理数据后,可以像数据库的聚合函数一样对某个字段进行操作。比如获取最大值,获取最小值,求总和,平均值,统计数量。

public class Demo {
    public static void main(String[] args) {
        Stream<Person> stream = Stream.of(
                new Person("张三", 58),
                new Person("李四", 56),
                new Person("王五", 54),
                new Person("赵六", 52));
        // 获取最大值
        // Optional<Person> max = stream.collect(Collectors.maxBy((s1, s2) -> s1.getAge() - s2.getAge()));
        // System.out.println("最大值: " + max.get());
        // 获取最小值
        // Optional<Person> min = stream.collect(Collectors.minBy((s1, s2) -> s1.getAge() - s2.getAge()));
        // System.out.println("最小值: " + min.get());
        // 求总和
        // Integer sum = stream.collect(Collectors.summingInt(s -> s.getAge()));
        // System.out.println("总和: " + sum);
        // 平均值
        // Double avg = stream.collect(Collectors.averagingInt(s -> s.getAge()));
        // Double avg = stream.collect(Collectors.averagingInt(Person::getAge));
        //System.out.println("平均值: " + avg);
        // 统计数量
        Long count = stream.collect(Collectors.counting());
        System.out.println("统计数量: " + count);
    }
}

对流中数据进行分组

当我们使用Stream流处理数据后,可以根据某个属性将数据分组:

public class Demo {
    public static void main(String[] args) {
        Stream<Person> stream = Stream.of(
                new Person("张三", 50),
                new Person("李四", 26),
                new Person("王五", 24),
                new Person("赵六", 50));
        // Map<Integer, List<Person>> map = stream.collect(Collectors.groupingBy(Person::getAge));
        // 将分数大于60的分为一组,小于60分成另一组
        Map<String, List<Person>> map =
                stream.collect(Collectors.groupingBy((s) -> {
                    if (s.getAge() > 30) {
                        return "老人";
                    } else {
                        return "年轻人";
                    }
                }));
        map.forEach((k, v) -> {
            System.out.println(k + "::" + v);
        });
    }
}

对流中数据进行多级分组

public class Demo {
    public static void main(String[] args) {
        Stream<Person> stream = Stream.of(
                new Person("张三", 50),
                new Person("李四四", 24),
                new Person("王五五", 24),
                new Person("李四四", 50),
                new Person("王五五", 24),
                new Person("赵六", 50));

        Map<Integer, Map<String, List<Person>>> map =
                stream.collect(Collectors.groupingBy(Person::getAge,
                        Collectors.groupingBy((s) -> {
                            if (s.getName().length() == 3) {
                                return "名字三个字";
                            } else {
                                return "其他";
                            }
                        })));

        map.forEach((k, v) -> {
            System.out.println(k);
            v.forEach((k2, v2) -> {
                System.out.println("\t" + k2 + " == " + v2);
            });
        });
    }
}

对流中数据进行分区

public class Demo {
    public static void main(String[] args) {
        Stream<Person> stream = Stream.of(
                new Person("张三", 50),
                new Person("李四", 34),
                new Person("王五", 24),
                new Person("赵六", 65));

        Map<Boolean, List<Person>> map =
                stream.collect(Collectors.partitioningBy(s -> {
                    return s.getAge() > 40;
                }));
        map.forEach((k, v) -> {
            System.out.println(k + " :: " + v);
        });
    }
}

对流中数据进行拼接

Collectors.joining 会根据指定的连接符,将所有元素连接成一个字符串。

public class Demo {
    public static void main(String[] args) {
        Stream<Person> stream = Stream.of(
                new Person("张三", 50),
                new Person("李四", 34),
                new Person("王五", 24),
                new Person("赵六", 65));

        // 根据一个字符串拼接: 赵丽颖__杨颖__迪丽热巴__柳岩
        // String names = stream.map(Person::getName).collect(Collectors.joining("_"));
        // 根据三个字符串拼接
        String names = stream.map(Person::getName).collect(Collectors.joining("__", "^_^","V_V"));
        System.out.println("names = " + names);
    }
}

标签:常用,stream,Stream,System,JDK8,println,new,public
From: https://www.cnblogs.com/yellow-mokey/p/17046096.html

相关文章

  • maya工作常用功能笔记
    maya工作常用功能笔记1.去除命名空间设置2.贴图替换重新指认路径......
  • Python学习笔记(4)~Python基础练习之常用内置函数(1-10)
    Python基础练习之常用内置函数(1-10)1、abs()作用        求数的绝对值或者复数的模测试demo#!/usr/bin/python3#abs:求绝对值or复数的模#|-1|=1a=abs(-1)#复数......
  • C#-文件操作的一些常用函数及压缩文件
    1.判断目录或文件是否存在(usingSystem.IO;):Directory.Exists(path);//目录是否存在File.Exists(filePath);//文件是否存在2.创建路径上所有目录及子目录:Directory.C......
  • git常用指令整理
    git常用命令gitremote//查看远程仓库(origin)gitbranch-a//查看当前git仓库的所有分支信息gitcheckout分支名称//切换到某一分支gitcheck......
  • C#-XML文件的一些常用操作
    记录一些常用的操作XML文档的方法,XML示例文档如下:<?xmlversion="1.0"encoding="utf-8"?><Animal><DogSound="WangWang"Favor="Bone"/><CatSound="MiaoMiao"......
  • ppt常用快捷键
    【Ctrl+B】添加/删除文本加粗【Ctrl+D】生成对象或幻灯片副本【Ctrl+E】段落居中对齐【Ctrl+L】段落左对齐【Ctrl+Shift+P】更改字号【Ctrl+G】组合对象【Ctrl+Shift......
  • git 常用命令
    项目推送到git:git init                             # 初始化本地版本库git remote add -A           #把当前目录下的......
  • 常用正则表达式
    一、js正则表达式 1、密码强度,至少包含大小写字母、特殊字符、数字三种及以上,长度8~20位varreg=/(?![a-zA-Z]+$)(?![A-Z0-9]+$)(?![A-Z\W_!@#$%^&*`~()-+=]+$)(?![......
  • 常用命令汇总
    Windowsnetstat-nao|find"关键字"//端口占用情况taskkill/pid19001/f//kill某进程taskkill/imtomcat7.exe/f//kill某程序CentOSnetstat-ntlp//列出......
  • Centos7防火墙常用命令
    https://blog.csdn.net/xyy1028/article/details/104787061一.系统防火墙1.启动防火墙systemctlstartfirewalld2.关闭防火墙systemctlstopfirewalld3.查看状态systemc......