手扶拖拉机_6e4d
手扶拖拉机_6e4d

java之Stream的常见用法

Stream 使用一种类似用 SQL 语句从数据库查询数据的直观方式来提供一种对 Java 集合运算和表达的高阶抽象, 是一个来自数据源的元素队列并支持聚合操作(https://upload-images.jianshu.io/upload_images/6348370-f8218715507512e1.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/1240)

Stream 可以对集合和数组进行一些简化操作,将集合或数组转化为Stream流，使用Stream流中的方法对集合/数组中的元素进行操作，解决集合中的一些弊端

和以前的Collection操作不同，Stream操作还有两个基础的特征

  • Pipelining:中间操作都会返回流对象本身，这样多个操作可以串联成一个管道，如果流式风格(fluent style),这样做可以对操作进行优化，比如延迟执行(laziness)和短路(short-circuiting)
  • 内部迭代：以前对集合遍历都是通过Iterator或者增强for的方式，显示的在集合外部进行迭代，这叫做外部迭代，Stream提供了内部迭代的方式，流可以直接调用遍历方法
  • 当使用一个流的时候，通常包括3个步骤：获取一个数据源(source) -> 数据转换 -> 执行操作获取想要的结果,每次转换原有Stream对象，返回一个新的Stream对象，这就允许对其操作可以向链条一样排列，变成一个管道
516E226E-0FFF-43E9-9283-779D9491EB38.png
  • Stream两种使用方法：
    1.在java.util.Collection 中有一个方法 default Stream
    2.java.util.stream接口的静态方法of可以获取数组对应的流
    static Stream of (T... values)
        List list = new ArrayList();
        Stream stream1 = list.stream();

        Set set = new HashSet();
        Stream stream2 = set.stream();

        Map map = new HashMap();
        Set keySet= map.keySet();
        Stream stream3 = keySet.stream();

        Collection collection = map.values();
        Stream stream4 = collection.stream();

        // 获取键值对的映射关系
        // Map.entrySet() 这个方法返回的是一个Set>，Map.Entry 是Map中的一个接口，他的用途是表示一个映射项（里面有Key和Value），
        // 而Set>表示一个映射项的Set。Map.Entry里有相应的getKey和getValue方法，即JavaBean，让我们能够从一个项中取出Key和Value
        Set> entries = map.entrySet();
        Stream> stream = entries.stream();

        // 数组转换为stream流
        Integer[] arr = {1,2,3,4,5};
        Stream stream5= Stream.of(arr);
  • 案例1 ： 对列表/数组中的每个元素都乘以2
package NewFeature.JavaStream;
import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;
import java.util.stream.IntStream;

public static void main(String[] args) {
    int[] list = IntStream.range(1, 10).map(i -> i*2).toArray();
        for (int value: list) {
            System.out.println(value);
        }

    // or
    List result = IntStream.range(10, 20).map(i -> i*2).boxed().collect(Collectors.toList());
        for (int value: result) {
            System.out.println(value);
        }
}

输出：

2
4
6
8
10
12
14
16
18
  • 案例2：筛选重复元素
List list = Arrays.asList(1,2,2,3,4,2,1,5);
list.stream().filter(i -> i%2 == 0).distinct().forEach(System.out::println);

输出：

2
4
  • 选出以"张"开头、长度为3的名字
        List list = new ArrayList();
        list.add("张三丰");
        list.add("马可波诺");
        list.add("张小龙");
        list.add("赵无极");
        list.add("青龙");
        list.add("乔峰");

        List shortList = new ArrayList<>();
        for (String name:list) {
            if (name.length() == 3 && name.startsWith("张")) {
                shortList.add(name);
            }
        }
        System.out.println("张开头并且长度为2的名字=" + shortList.toString())

list.stream().filter(value -> value.startsWith("张"))
                .filter(value -> value.length() == 3)
                .collect(Collectors.toList()).forEach(System.out::print);
  • 案例3：限制元素数量
List list = Arrays.asList(2,5,6,6,8,2,12,63,53,13,76);
        list.stream().filter(i -> i>5).
                distinct().
                limit(3).
//                skip(1).
                collect(Collectors.toList()).
                forEach(System.out::println);

输出：

6
8
12

// 加了skip(1)
8
12
  • 案例4: Stream支持map方法，接收一个函数作为参数，这个函数被应用到每个元素上，并将其映射成一个新元素
List list = Arrays.asList("wudy", "macBook", "china hello");
        List wordLens = list.stream().map(String::length).collect(Collectors.toList());
        for (Integer item:wordLens) {
            System.out.println("长度=" + item);
        }

输出：

长度=4
长度=7
长度=11
  • 案例5：flatmap方法让你把一个流中的每个值都换成另一个流，然后把所有的流连接起来成为一个流
List list = Arrays.asList("Hello", "World");
        list.stream().map(word -> word.split(""))
                     .flatMap(Arrays::stream)
                     .distinct()
                     .collect(Collectors.toList())
                     .forEach(System.out::print)

输出：

HeloWrd

如下图：


B6AC3DC1-1866-434E-AF24-A4A6FA232579.png

-案例6：给定两个数字列表，返回所有的数对？例如：给定列表[1,3]、[2,4,6], 应该返回[(1,2),(1,4),(1,6),(3,2),(3,4),(3,6)]

List list1 = Arrays.asList(1,3);
        List list2 = Arrays.asList(2,4,6);
        List pairs = list1.stream().flatMap(i -> list2.stream()
                                          .map(j -> new int[] {i, j}))
                                          .collect(Collectors.toList());
        // pairs.stream().forEach(item -> Arrays.stream(item).forEach();
        for (int [] item: pairs) {
            System.out.println(Arrays.toString(item));
        }

输出:

[1, 2]
[1, 4]
[1, 6]
[3, 2]
[3, 4]
[3, 6]
  • 案例7: 匹配给定的谓词
List list = Arrays.asList("wudy","peter");
        if (list.stream().anyMatch(value -> value.equals("peter"))) {
            System.out.println("匹配到了给定的谓词");
        }

输出：

匹配到了给定的谓词
  • 案例8: 流中是否所有的元素能匹配给定的谓词
List list = Arrays.asList(5,7,11,423,54);
        if (list.stream().allMatch(value -> value > 3)) {
            System.out.println("匹配了所有的谓词");
        }

输出：

匹配了所有的谓词
  • 案例9: 流中没有任何元素能匹配给定的谓词
List list = Arrays.asList(101,198,112,423,354);
        if (list.stream().noneMatch(value -> value < 100)) {
            System.out.println("都能活到100岁");
        }

输出：

都能活到100岁
  • 案例10: 求Sum、max
List list = Arrays.asList(1,2,3,4,5,6);
//        Integer sum = list.stream().reduce(0, (a, b) -> a + b);
        Integer sum = list.stream().reduce(0, Integer::sum);
        System.out.println("sum=" + sum);

        Integer max = list.stream().reduce(0, Integer::max);
        System.out.println("max=" + max);

输出：

sum=21
max=6
  • 案例11：现在有一个List集合，想对该集合中的数据分组处理
package NewFeature.JavaStream;

public class User {
    private  Integer id;
    private  Integer age;
    private  String name;

    public User(Integer id, Integer age, String name) {
        this.id = id;
        this.age = age;
        this.name = name;
    }

    public Integer getId() {
        return id;
    }

    public Integer getAge() {
        return age;
    }

    public String getName() {
        return name;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public void setAge(Integer age) {
        this.age = age;
    }

    public void setName(String name) {
        this.name = name;
    }

}


package NewFeature.JavaStream;

import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

/**
 * 现在有一个List集合，想对该集合中的数据分组处理
 */
public class StreamDemo {
    public static void main(String[] args) {
        List list = getUserList();
        Map> userGroupList = list.stream().collect(Collectors.groupingBy(User::getAge));
        System.out.println(userGroupList);
//        for (Integer key: userGroupList.keySet()) {
//            System.out.println(userGroupList.get(key));
//        }
//
//        for (List value: userGroupList.values()) {
//            System.out.println(value);
//        }
    }

    public static ArrayList getUserList() {
        User user1 = new User(1, 18, "wudy");
        User user2 = new User(2, 20, "peter");
        User user3 = new User(3, 30, "timo");
        User user4 = new User(4, 20, "chimmy");

        ArrayList arrayList = new ArrayList();
        arrayList.add(user1);
        arrayList.add(user2);
        arrayList.add(user3);
        arrayList.add(user4);
        return arrayList;
    }
}

输出：

{18=[NewFeature.JavaStream.User@5b6f7412], 20=[NewFeature.JavaStream.User@27973e9b, NewFeature.JavaStream.User@312b1dae], 30=[NewFeature.JavaStream.User@7530d0a]}
  • Java8中Stream对列表去重的几种方法

1.distinct() 对于 String 列表的去重

 @Test
    public void stream1(){
        List list = new ArrayList<>();
        list.add("A");
        list.add("C");
        list.add("B");
        list.add("C");

        System.out.println("去重前=" + list);
        list = list.stream().distinct().collect(Collectors.toList());
        System.out.println("去重后=" + list);
    }

去重前=[A, C, B, C]
去重后=[A, C, B]

2.对实体类列表的去重

// 定义实体类
@Data
@AllArgsConstructor
@NoArgsConstructor
@TableName(value = "message")
public class Message implements Serializable {
   @ApiModelProperty(value = "用户司机企业的id")
    private Long uid;

    @ApiModelProperty(value = "客服id")
    private String agentId;

    @ApiModelProperty(value = "客服名称")
    private String agentName;
}

// 实现类 MessageServiceImpl
package cn.huolala.llim.im.service.impl;


@Service
public class MessageServiceImpl extends ServiceImpl implements IMessageService {

    @Autowired
    private IMessageMapper iMessageMapper;

    @Override
    public List queryList(Message message, PageBO pager) {
        // 多条件构造器
        QueryWrapper queryWrapper = new QueryWrapper<>();
        queryWrapper
                .select("uid", "agent_id", "agent_name")  // 查询指定字段
                .isNotNull("uid").eq("uid", message.getUid());

        queryWrapper.orderByDesc("created_at");
        Page page = new Page<>(pager.getPage_no(), pager.getPage_size());
        page = iMessageMapper.selectPage(page, queryWrapper);
        return page.getRecords();
    }
}


import static java.util.stream.Collectors.collectingAndThen;
import static java.util.stream.Collectors.toCollection;

 @Test
    public void stream() throws JsonProcessingException {
        ObjectMapper objectMapper = new ObjectMapper();
        Message message = new Message();
        message.setUid(113074491521L);

        PageBO page = new PageBO();
        page.setPage_no(1);
        page.setPage_size(10);

        // 1. 对于 Message 列表去重
        List messageList = iMessageService.queryList(message, page);
        System.out.println("去重前=" + messageList);
//        System.out.println("writeValueAsString = " + objectMapper.writeValueAsString(messageList));
        messageList = messageList.stream().distinct().collect(Collectors.toList());
        System.out.println("去重后=" + messageList);
//        System.out.println("writeValueAsString = " + objectMapper.writeValueAsString(messageList));

        messageList = messageList.stream().collect(
                collectingAndThen(
                        toCollection(() -> new TreeSet<>(Comparator.comparing(Message::getAgentId))), ArrayList::new)
        );
        System.out.println("根据agentID去重后=" + messageList);
    }

<==    Columns: uid, agent_id, agent_name
<==        Row: 113074491521, 107, wudy.yu2
<==        Row: 113074491521, 107, wudy.yu
<==        Row: 113074491521, 108, wudy.yu3
<==        Row: 113074491521, 107, wudy.yu


去重前=[Message(uid=113074491521, agentId=107, agentName=wudy.yu2), Message(uid=113074491521, agentId=107, agentName=wudy.yu), Message(uid=113074491521, agentId=108, agentName=wudy.yu3), Message(uid=113074491521, agentId=107, agentName=wudy.yu)]
去重后=[Message(uid=113074491521, agentId=107, agentName=wudy.yu2), Message(uid=113074491521, agentId=107, agentName=wudy.yu), Message(uid=113074491521, agentId=108, agentName=wudy.yu3)]
根据agentID去重后=[Message(uid=113074491521, agentId=107, agentName=wudy.yu2), Message(uid=113074491521, agentId=108, agentName=wudy.yu3)]

3.根据List中 Object 某个属性去重

// 见上例
messageList = messageList.stream().collect(
                collectingAndThen(
                        toCollection(() -> new TreeSet<>(Comparator.comparing(Message::getAgentId))), ArrayList::new)
        );

4.通过 filter() 方法

//我们首先创建一个方法作为 Stream.filter() 的参数，其返回类型为 Predicate，原理就是判断一个元素能否加入到 Set 中去，代码如下：

private static  Predicate distinctByKey(Function keyExtractor){
        Set seen = ConcurrentHashMap.newKeySet();
        return t -> seen.add(keyExtractor.apply(t));
    }
 
 
 @Test
    public void stream() throws JsonProcessingException {
        ObjectMapper objectMapper = new ObjectMapper();
        Message message = new Message();
        message.setUid(113074491521L);

        PageBO page = new PageBO();
        page.setPage_no(1);
        page.setPage_size(10);

        // 1. 对于 Message 列表去重
        List messageList = iMessageService.queryList(message, page);
        System.out.println("去重前=" + messageList);
        messageList = messageList.stream().distinct().collect(Collectors.toList());
        System.out.println("去重后=" + messageList);

        //这里我们将 distinctByKey() 方法作为 filter() 的参数，过滤掉那些不能加入到 set 的元素
        messageList = messageList.stream().filter(distinctByKey(Message::getAgentId)).collect(Collectors.toList());
        System.out.println("根据agentID去重后=" + messageList);
    }

 
 
<==    Columns: uid, agent_id, agent_name
<==        Row: 113074491521, 107, wudy.yu2
<==        Row: 113074491521, 107, wudy.yu
<==        Row: 113074491521, 108, wudy.yu3
<==        Row: 113074491521, 107, wudy.yu
<==      Total: 4
Closing non transactional SqlSession [org.apache.ibatis.session.defaults.DefaultSqlSession@1f6af096]
去重前=[Message(uid=113074491521, agentId=107, agentName=wudy.yu2), Message(uid=113074491521, agentId=107, agentName=wudy.yu), Message(uid=113074491521, agentId=108, agentName=wudy.yu3), Message(uid=113074491521, agentId=107, agentName=wudy.yu)]
去重后=[Message(uid=113074491521, agentId=107, agentName=wudy.yu2), Message(uid=113074491521, agentId=107, agentName=wudy.yu), Message(uid=113074491521, agentId=108, agentName=wudy.yu3)]
根据agentID去重后=[Message(uid=113074491521, agentId=107, agentName=wudy.yu2), Message(uid=113074491521, agentId=108, agentName=wudy.yu3)]

 
 
     
  
  • 案例1
    •  
 
 
 
 
  
如果有一个需求，需要对数据库查询到的菜肴进行一个处理：
 筛选出卡路里小于400的菜肴
 对筛选出的菜肴进行一个排序
 获取排序后菜肴的名字
 
 
 
 
public class Dish {
    private String name;
    private boolean vegetarian;
    private int calories;
    private Type type;

    // getter and setter
}

 
 
// java8之前的实现方式
private List beforeJava7(List dishList) {
        List lowCaloricDishes = new ArrayList<>();

        //1.筛选出卡路里小于400的菜肴
        for (Dish dish : dishList) {
            if (dish.getCalories() < 400) {
                lowCaloricDishes.add(dish);
            }
        }

        //2.对筛选出的菜肴进行排序
        Collections.sort(lowCaloricDishes, new Comparator() {
            @Override
            public int compare(Dish o1, Dish o2) {
                return Integer.compare(o1.getCalories(), o2.getCalories());
            }
        });

        //3.获取排序后菜肴的名字
        List lowCaloricDishesName = new ArrayList<>();
        for (Dish d : lowCaloricDishes) {
            lowCaloricDishesName.add(d.getName());
        }

        return lowCaloricDishesName;
    }

 
 
// java8之后的实现方式
 private List afterJava8(List dishList) {
        return dishList.stream()
                .filter(d -> d.getCalories() < 400)  //筛选出卡路里小于400的菜肴
                .sorted(comparing(Dish::getCalories))  //根据卡路里进行排序
                .map(Dish::getName)  //提取菜肴名称
                .collect(Collectors.toList()); //转换为List
    }

 
 
 
  
高高兴兴写完需求这时候又有新需求了，新需求如下：
 对数据库查询到的菜肴根据菜肴种类进行分类，返回一个Map>的结果
 这要是放在jdk8之前肯定会头皮发麻
 
 
 
 
// java8之前的实现方式
private static Map> beforeJdk8(List dishList) {
    Map> result = new HashMap<>();

    for (Dish dish : dishList) {
        //不存在则初始化
        if (result.get(dish.getType())==null) {
            List dishes = new ArrayList<>();
            dishes.add(dish);
            result.put(dish.getType(), dishes);
        } else {
            //存在则追加
            result.get(dish.getType()).add(dish);
        }
    }

    return result;
}

 
 
// java8的实现方式
private static Map> afterJdk8(List dishList) {
    return dishList.stream().collect(groupingBy(Dish::getType));
}

 
 
 
  
一、什么是流？
 流是从支持数据处理操作的源生成的元素序列，源可以是数组、文件、集合、函数。流不是集合元素，它不是数据结构并不保存数据，它的主要目的在于计算
 
 
 
 
 
  
二、如何生成流
 生成流的方式主要有五种:
 
 
 
 
// 2.1>通过集合生成，应用中最常用的一种
List integerList = Arrays.asList(1, 2, 3, 4, 5);
Stream stream = integerList.stream();

 
 
// 2.2>通过集合的stream方法生成流
// 2.2.1> 通过数组生成
int[] intArr = new int[]{1, 2, 3, 4, 5};
IntStream stream = Arrays.stream(intArr);
/*
通过Arrays.stream方法生成流，并且该方法生成的流是数值流【即IntStream】而不是Stream。
补充一点使用数值流可以避免计算过程中拆箱装箱，提高性能。Stream API提供了mapToInt、mapToDouble、mapToLong三种方式将对象流
【即Stream】转换成对应的数值流，同时提供了boxed方法将数值流转换为对象流
*/

// 2.2.2> 通过值生成
// 通过Stream的of方法生成流，通过Stream的empty方法可以生成一个空流
Stream stream = Stream.of(1, 2, 3, 4, 5);


// 2.3> 通过文件生成
// 通过Files.line方法得到一个流，并且得到的每个流是给定文件中的一行
Stream lines = Files.lines(Paths.get("data.txt"), Charset.defaultCharset())

//2.4> 通过函数生成 
//提供了iterate和generate两个静态方法从函数中生成流
Stream stream = Stream.iterate(0, n -> n + 2).limit(5);

// iterate方法接受两个参数，第一个为初始化值，第二个为进行的函数操作，因为iterator生成的流为无限流，通过limit方法对流进行了截断，只生成5个偶数


Stream stream = Stream.generate(Math::random).limit(5);
//generate方法接受一个参数，方法参数类型为Supplier，
//由它为流提供值。generate生成的流也是无限流，因此通过limit对流进行了截断

 
 
     
  
  • 流的操作类型
    •  
 
 
 
 
  
流的操作类型主要分为两种:
 1.中间操作 一个流可以后面跟随零个或多个中间操作。其目的主要是打开流，做出某种程度的数据映射/过滤，然后返回一个新的流，交给下一个操作使用。这类操作都是惰性化的，仅仅调用到这类方法，并没有真正开始流的遍历，真正的遍历需等到终端操作时，常见的中间操作有下面即将介绍的filter、map等
 2.终端操作 一个流有且只能有一个终端操作，当这个操作执行后，流就被关闭了，无法再被操作，因此一个流只能被遍历一次，若想在遍历需要通过源数据在生成流。终端操作的执行，才会真正开始流的遍历。如下面即将介绍的count、collect等
 
 
 
 
参考资料: https://mp.weixin.qq.com/s?__biz=MzUxOTc4NjEyMw==&mid=2247506967&idx=2&sn=c9c4b190331dc53faf77f8185e9fd534&chksm=f9f6c7f3ce814ee59109d3f2496eae5feaa46ef09fbc098e2c0d02be591fdeb043a3389c0cbc&mpshare=1&scene=23&srcid=0427RZolHIHFZHAY2n3NoRkE&sharer_sharetime=1619505638932&sharer_shareid=f770d25bc57f1c2f9159f85750f854dc#rd
 
 
     
  
  • Stream对列表去重的几种方法
    •  
 
 
 
 
  
     
   
  • 1.Stream的distinct方法
     distinct()是Java 8 中 Stream 提供的方法，返回的是由该流中不同元素组成的流。distinct()使用 hashCode() 和 eqauls() 方法来获取不同的元素。
     因此，需要去重的类必须实现 hashCode()和 equals() 方法。换句话讲，我们可以通过重写定制的 hashCode() 和equals()方法来达到某些特殊需求的去重。
     distinct() 方法声明如下:
    •  
   
  • 1.1 对String列表去重:
     因为 String 类已经覆写了 equals() 和 hashCode() 方法，所以可以去重成功
    •  
  
 
 
 
 
@Test
    public void distinct(){
        List stringList = new ArrayList(){
            {
                add("A");
                add("B");
                add("C");
                add("A");
            }
        };
        System.out.println("去重前:");
        for (String s : stringList){
            System.out.println(s);
        }

        stringList = stringList.stream().distinct().collect(Collectors.toList());

        System.out.println("去重后:");
        for (String s : stringList){
            System.out.println(s);
        }
    }


 
 
 
  
去重前:
 A
 B
 C
 A
 去重后:
 A
 B
 C
 
 
 
 
 
  
     
   
  • 1.2 对实体类列表的去重
     注：代码中我们使用了 Lombok 插件的 @Data注解，可自动覆写 equals() 以及 hashCode()方法
    •  
  
 
 
 
 
@Test
    public void distinct() throws JsonProcessingException {
        ObjectMapper mapper = new ObjectMapper();
        List sList = new ArrayList<>();
        Student s1 = Student.builder().stuNo("001").name("wudy").build();
        Student s2 = Student.builder().stuNo("002").name("peter").build();
        Student s3 = Student.builder().stuNo("001").name("wudy").build();

        sList.add(s1);
        sList.add(s2);
        sList.add(s3);

        System.out.printf("去重前:" + mapper.writeValueAsString(sList));
        sList = sList.stream().distinct().collect(Collectors.toList());
        System.out.printf("去重后:" + mapper.writeValueAsString(sList));
    }

 
 
 
  
去重前：[{"stuNo":"001","name":"Tom"},{"stuNo":"002","name":"Mike"},{"stuNo":"001","name":"Tom"}]
 去重后：[{"stuNo":"001","name":"Tom"},{"stuNo":"002","name":"Mike"}]
 
 
 
 
 
  
     
   
  • 1.3 根据List中Object某个属性去重 
   
  
 
    import static java.util.stream.Collectors.collectingAndThen;
import static java.util.stream.Collectors.toCollection;

 @Test
    public void test21() throws JsonProcessingException {
        List list = new ArrayList<>();
        Student s1 = Student.builder().stuNo("001").stuName("wudy").build();
        Student s2 = Student.builder().stuNo("002").stuName("peter").build();
        Student s3 = Student.builder().stuNo("001").stuName("wudy").build();

        list.add(s1);
        list.add(s2);
        list.add(s3);

        ObjectMapper mapper = new ObjectMapper();
        System.out.printf("去重前=" + mapper.writeValueAsString(list));

        list = list.stream().collect(
                collectingAndThen(
                        toCollection(() -> new TreeSet<>(Comparator.comparing(Student::getStuName))), ArrayList::new)
        );

        System.out.printf("去重后=" + mapper.writeValueAsString(list));
    }

     
 
     
  
    去重前=[{"stuName":"wudy","stuNo":"001"},{"stuName":"peter","stuNo":"002"},{"stuName":"wudy","stuNo":"001"}]
     去重后=[{"stuName":"peter","stuNo":"002"},{"stuName":"wudy","stuNo":"001"}]
     
 
     
 
     
  
       
   
    • 1.4 通过filter方法去重
      •  
  
     
 
     
 
    @Test
    public void test21() throws JsonProcessingException {
        List list = new ArrayList<>();
        Student s1 = Student.builder().stuNo("001").stuName("wudy").build();
        Student s2 = Student.builder().stuNo("002").stuName("peter").build();
        Student s3 = Student.builder().stuNo("001").stuName("wudy").build();

        list.add(s1);
        list.add(s2);
        list.add(s3);

        ObjectMapper mapper = new ObjectMapper();
        System.out.printf("去重前=" + mapper.writeValueAsString(list));

        // 将 distinctByKey() 方法作为 filter() 的参数，过滤掉那些不能加入到 set 的元素
        list = list.stream().filter(dictinctByKey(Student::getStuName)).collect(Collectors.toList());

        System.out.printf("去重后=" + mapper.writeValueAsString(list));
    }

    private static  Predicate dictinctByKey(Function keyExtractor){
        Set keys = ConcurrentHashMap.newKeySet();
        return t -> keys.add(keyExtractor.apply(t));
    }
 
 
     
  
    去重前=[{"stuName":"wudy","stuNo":"001"},{"stuName":"peter","stuNo":"002"},{"stuName":"wudy","stuNo":"001"}]
     去重后=[{"stuName":"wudy","stuNo":"001"},{"stuName":"peter","stuNo":"002"}]
     
 
     
 
       
  
    • Stream图解
      •  
 
     
 
     
  
     
  
     
   
     
    
      
    
     
   
     
   
    
     image.png 
   
     
  
     
  
     Stream将要处理的元素集合看作一种流，在流的过程中，借助Stream API对流中的元素进行操作，比如：筛选、排序、聚合等 
  
     Stream可以由数组或集合创建，对流的操作分为两种： 
  
     中间操作，每次返回一个新的流，可以有多个。 
  
     终端操作，每个流只能进行一次终端操作，终端操作结束后流无法再次使用。终端操作会产生一个新的集合或值。 
  
     另外，Stream有几个特性： 
  
     
  
       
   
    • stream不存储数据，而是按照特定的规则对数据进行计算，一般会输出结果。
      •  
   
    • stream不会改变数据源，通常情况下会产生一个新的集合或一个值。
      •  
   
    • stream具有延迟执行特性，只有调用终端操作时，中间操作才会执行。
      •  
  
     
 
     
 
       
  
    • 1.Stream创建:
       1.1> Stream可以通过集合数组创建,通过 java.util.Collection.stream() 方法用集合创建流
      •  
 
     
 
    List list = Arrays.asList("a", "b", "c");
// 创建一个顺序流
Stream stream = list.stream();
// 创建一个并行流
Stream parallelStream = list.parallelStream();

     
 
    1.2> 使用java.util.Arrays.stream(T[] array)方法用数组创建流
     
 
    int[] array={1,3,5,6,8};
IntStream stream = Arrays.stream(array);

     
 
    1.3> 使用Stream的静态方法：of()、iterate()、generate()
     
 
    Stream stream = Stream.of(1, 2, 3, 4, 5, 6);

Stream stream2 = Stream.iterate(0, (x) -> x + 3).limit(4);
stream2.forEach(System.out::println); // 0 2 4 6 8 10

Stream stream3 = Stream.generate(Math::random).limit(3);
stream3.forEach(System.out::println);


     
 
    stream和parallelStream的简单区分： stream是顺序流，由主线程按顺序对流执行操作，而parallelStream是并行流，内部以多线程并行执行的方式对流进行操作，但前提是流中的数据处理没有顺序要求。例如筛选集合中的奇数，两者的处理不同之处
     
 
     
  
     
   
      
   
     
  
     
  
    
    image.png 
  
     
 
     
 
       
  
    • Stream的案例使用
       https://mp.weixin.qq.com/s?__biz=MzI3ODcxMzQzMw==&mid=2247539728&idx=2&sn=a3397ae7db0d7c13f21ae4d650b237ec&chksm=eb50d926dc275030a3ac919708b53af1a4bd339bce6e4f1351fd1eb88f9a5c2fdecdd2c6b02b&mpshare=1&scene=23&srcid=08216nSfljTSZcpp5Nql4z7m&sharer_sharetime=1629510377638&sharer_shareid=f770d25bc57f1c2f9159f85750f854dc%23rd
      •  
  
    • Stream简单案例
      •  
 
     
 
    https://mp.weixin.qq.com/s?__biz=MzUxOTc4NjEyMw==&mid=2247533024&idx=3&sn=393d7130c992ab67d5ce2dde66b165dc&chksm=f9f65a04ce81d312c3edc482d796f68b250e9bca943c77ce10e36e16e6a3c0850f10d58a7c24&mpshare=1&scene=23&srcid=0521nfdgr7cnkMhqRtFFGqz2&sharer_sharetime=1653147530521&sharer_shareid=7fec9c1809ccb850bfdebba7d4f7a81e%23rd

     
 
           // 1.list => 数组
        List arrayList = new ArrayList(Arrays.asList(1,3,5,7,9));
//        int[] arr = arrayList.stream().mapToInt((item) -> Integer.valueOf(item)).toArray();
        int[] arr = arrayList.stream().mapToInt(Integer::intValue).toArray();


        for (int i=0;i k, k -> 1, Integer::sum))
                .forEach((k, v) -> System.out.println(k + ": " + v));


        // 4.基本数据类型的数组自定义排序
        int[] arr4 = {1, 5, 9, 7, 2, 3, 7, -1, 0, 3};
        int[] arr5 = IntStream.of(arr4).boxed()
                      .sorted(Comparator.reverseOrder())
                      .mapToInt(Integer::intValue)
                      .toArray();
        for (Integer item:arr5) {
            System.out.println("item5="+ item);
        }

        // 5.统计数组中前 k 个个高频元素
        int[] arr6 = {1,3,2,55,33,3,6,1,55,3,2,0,98,3,1,41,52,2,1,3};
        int[] arr7 = Arrays.stream(arr6)
                .boxed()
                .collect(Collectors.toMap(e -> e, e -> 1, Integer::sum))
                .entrySet()
                .stream()
                .sorted((m1, m2) -> m2.getValue() - m1.getValue())
                .limit(2)
                .mapToInt(Map.Entry::getKey)
                .toArray();

        for (Integer item:arr7) {
            System.out.println("item7="+ item);
        }

     

                            
                        
                    
                    
                    
    
                    
                    
                    
    
                
                
    
                    
                
    
            
        
    
    
    
        
    你可能感兴趣的:(java之Stream的常见用法)
    
        
    
            
    
                
      
                    
    • 斤斤计较的婚姻到底有多难？
                        白心之岂必有为

                        
      很多人私聊我会问到在哪个人群当中斤斤计较的人最多？我都会回答他，一般婚姻出现问题的斤斤计较的人士会非常多，以我多年经验，在婚姻落的一塌糊涂的人当中，斤斤计较的人数占比在20～30%以上，也就是说10个婚姻出现问题的斤斤计较的人有2-3个有多不减。在婚姻出问题当中，有大量的心理不平衡的、尖酸刻薄的怨妇。在婚姻中仅斤斤计较有两种类型：第一种是物质上的，另一种是精神上的。在物质与精神上抠门已经严重的影响
      
                    
      • 
                    
    • 情绪觉察日记第37天
                        露露_e800

                        
      今天是家庭关系规划师的第二阶最后一天，慧萍老师帮我做了个案，帮我处理了埋在心底好多年的一份恐惧，并给了我深深的力量！这几天出来学习，爸妈过来婆家帮我带小孩，妈妈出于爱帮我收拾东西，并跟我先生和婆婆产生矛盾，妈妈觉得他们没有照顾好我…。今晚回家见到妈妈，我很欣赏她并赞扬她，妈妈说今晚要跟我睡我说好，当我们俩躺在床上准备睡觉的时候，我握着妈妈的手对她说:妈妈这几天辛苦你了，你看你多利害把我们的家收拾得
      
                    
      • 
                    
    • 芦花鞋一四
                        许叶晗

                        
      又是在一个寒冷的夏日里，青铜和葵花决定今天一起去卖芦花鞋，奶奶亲手给他们做了一碗热乎乎的粥对他们说:“就靠你们两挣生活费了这碗粥赶紧趁热喝了吧！”于是青铜和葵花喝完了奶奶给她们做的粥，就准备去镇上卖卢花鞋，这回青铜和葵花穿着新的芦花鞋来到了镇上。青铜这回看到了很多人都在卖，用手势表达对葵花说:“这回有好多人在抢我们生意呢！我们必须得吆喝起来。”葵花点了点头。可是谁知他们也大声的叫，卖芦花喽！卖芦花
      
                    
      • 
                    
    • QQ群采集助手，精准引流必备神器
                        2401_87347160
其他经验分享
                        
      功能概述微信群查找与筛选工具是一款专为微信用户设计的辅助工具，它通过关键词搜索功能，帮助用户快速找到相关的微信群，并提供筛选是否需要验证的群组的功能。主要功能关键词搜索：用户可以输入关键词，工具将自动查找包含该关键词的微信群。筛选功能：工具提供筛选机制，用户可以选择是否只显示需要验证或不需要验证的群组。精准引流：通过上述功能，用户可以更精准地找到目标群组，进行有效的引流操作。3.设备需求该工具可以
      
                    
      • 
                    
    • 关于沟通这件事，项目经理不需要每次都面对面进行
                        流程大师兄

                        
      很多项目经理都会遇到这样的问题，项目中由于事情太多，根本没有足够的时间去召开会议，那在这种情况下如何去有效地管理项目中的利益相关者？当然，不建议电子邮件也不需要开会的话，建议可以采取下面几种方式来形成有效的沟通，这几种方式可以帮助你努力的通过各种办法来保持和各方面的联系。项目经理首先要问自己几个问题，项目中哪些利益相关者是必须要进行沟通的？可以列出项目中所有的利益相关者清单，同时也整理出项目中哪些
      
                    
      • 
                    
    • 机器学习与深度学习间关系与区别
                        ℒℴѵℯ心·动ꦿ໊ོ꫞
人工智能学习深度学习python
                        
      一、机器学习概述定义机器学习（MachineLearning,ML）是一种通过数据驱动的方法，利用统计学和计算算法来训练模型，使计算机能够从数据中学习并自动进行预测或决策。机器学习通过分析大量数据样本，识别其中的模式和规律，从而对新的数据进行判断。其核心在于通过训练过程，让模型不断优化和提升其预测准确性。主要类型1.监督学习（SupervisedLearning）监督学习是指在训练数据集中包含输入
      
                    
      • 
                    
    • 铭刻于星（四十二）
                        随风至

                        
      69夜晚，绍敏同学做完功课后，看了眼房外，没听到动静才敢从书包的夹层里拿出那个心形纸团。折痕压得很深，都有些旧了，想来是已经写好很久了。绍敏同学慢慢地、轻轻地捏开折叠处，待到全部拆开后，又反复抚平纸张，然后仔细地一字字默看。只是开头的三个字是第一次看到，让她心漏跳了几拍。“亲爱的绍敏：从四年级的时候，我就喜欢你了，但是我一直不敢说，怕影响你学习。六年级的时候听说有人跟你表白，你接受了，我很难过，但
      
                    
      • 
                    
    • 底层逆袭到底有多难，不甘平凡的你准备好了吗？让吴起给你说说
                        造命者说

                        
      底层逆袭到底有多难，不甘平凡的你准备好了吗？让吴起给你说说我叫吴起，生于公元前440年的战国初期，正是群雄并起、天下纷争不断的时候。后人说我是军事家、政治家、改革家，是兵家代表人物。评价我一生历仕鲁、魏、楚三国，通晓兵家、法家、儒家三家思想，在内政军事上都有极高的成就。周安王二十一年（公元前381年），因变法得罪守旧贵族，被人乱箭射死。我出生在卫国一个“家累万金”的富有家庭，从年轻时候起就不甘平凡
      
                    
      • 
                    
    • 2020-01-25
                        晴岚85

                        
      郑海燕坚持分享590天2020.1.24在生活中只存在两个问题。一个问题是：你知道想要达成的目标是什么，但却不知道如何才能达成；另一个问题是：你不知道你的目标是什么。前一个是行动的问题，后一个是结果的问题。通过制定具体的下一步行动，可以解决不知道如何开始行动的问题。而通过去想象结果，对结果做预估，可以解决找不着目标的问题。对于所有吸引我们注意力，想要完成的任务，你可以先想象一下，预期的结果究竟是什
      
                    
      • 
                    
    • 随笔 | 仙一般的灵气
                        海思沧海

                        
      仙岛今天，我看了你全部，似乎已经进入你的世界我不知道，这是否是梦幻，还是你仙一般的灵气吸引了我也许每一个人都要有一份属于自己的追求，这样才能够符合人生的梦想，生活才能够充满着阳光与快乐我不知道，我为什么会这样的感叹，是在感叹自己的人生，还是感叹自己一直没有孜孜不倦的追求只感觉虚度了光阴，每天活在自己的梦中，活在一个不真实的世界是在逃避自己，还是在逃避周围的一切有时候我嘲笑自己，嘲笑自己如此的虚无，
      
                    
      • 
                    
    • 想家
                        爆米花机

                        
      也许不同于大家对家乡的思念，我对家乡甚至是疯狂的不舍。还未踏出车站就感觉到幸福，我享受这里的夕阳、这里的浓烈柴火味、这里每一口家常菜。我是宅女，我贪恋家的安逸。刚刚踏出大学校门，初出茅庐，无法适应每年只能国庆和春节回家。我焦虑、失眠、无端发脾气，是无法适应工作的节奏，是无法接受我将一步步离开家乡的事实。我不想承认自己胸无大志，选择再次踏上征程。图片发自App
      
                    
      • 
                    
    • 【iOS】MVC设计模式
                        Magnetic_h
iosmvc设计模式objective-c学习ui
                        
      MVC前言如何设计一个程序的结构，这是一门专门的学问，叫做"架构模式"（architecturalpattern），属于编程的方法论。MVC模式就是架构模式的一种。它是Apple官方推荐的App开发架构，也是一般开发者最先遇到、最经典的架构。MVC各层controller层Controller/ViewController/VC（控制器）负责协调Model和View，处理大部分逻辑它将数据从Mod
      
                    
      • 
                    
    • OC语言多界面传值五大方式
                        Magnetic_h
iosui学习objective-c开发语言
                        
      前言在完成暑假仿写项目时，遇到了许多需要用到多界面传值的地方，这篇博客来总结一下比较常用的五种多界面传值的方式。属性传值属性传值一般用前一个界面向后一个界面传值，简单地说就是通过访问后一个视图控制器的属性来为它赋值，通过这个属性来做到从前一个界面向后一个界面传值。首先在后一个界面中定义属性@interfaceBViewController:UIViewController@propertyNSSt
      
                    
      • 
                    
    • 一百九十四章. 自相矛盾
                        巨木擎天

                        
      唉！就这么一夜，林子感觉就像过了很多天似的，先是回了阳间家里，遇到了那么多不可思议的事情儿。特别是小伙伴们，第二次与自己见面时，僵硬的表情和恐怖的气氛，让自己如坐针毡，打从心眼里难受！还有东子，他现在还好吗？有没有被人欺负？护城河里的小鱼小虾们，还都在吗？水不会真的干枯了吧？那对相亲相爱漂亮的太平鸟儿，还好吧！春天了，到了做窝、下蛋、喂养小鸟宝宝的时候了，希望它们都能够平安啊！虽然没有看见家人，也
      
                    
      • 
                    
    • UI学习——cell的复用和自定义cell
                        Magnetic_h
ui学习
                        
      目录cell的复用手动（非注册）自动（注册）自定义cellcell的复用在iOS开发中，单元格复用是一种提高表格（UITableView）和集合视图（UICollectionView）滚动性能的技术。当一个UITableViewCell或UICollectionViewCell首次需要显示时，如果没有可复用的单元格，则视图会创建一个新的单元格。一旦这个单元格滚动出屏幕，它就不会被销毁。相反，它被添
      
                    
      • 
                    
    • element实现动态路由+面包屑
                        软件技术NINI
vue案例vue.js前端
                        
      el-breadcrumb是ElementUI组件库中的一个面包屑导航组件，它用于显示当前页面的路径，帮助用户快速理解和导航到应用的各个部分。在Vue.js项目中，如果你已经安装了ElementUI，就可以很方便地使用el-breadcrumb组件。以下是一个基本的使用示例：安装ElementUI（如果你还没有安装的话）:你可以通过npm或yarn来安装ElementUI。bash复制代码npmi
      
                    
      • 
                    
    • 10月|愿你的青春不负梦想-读书笔记-01
                        Tracy的小书斋

                        
      本书的作者是俞敏洪，大家都很熟悉他了吧。俞敏洪老师是我行业的领头羊吧，也是我事业上的偶像。本日摘录他书中第一章中的金句：『一个人如果什么目标都没有，就会浑浑噩噩，感觉生命中缺少能量。能给我们能量的，是对未来的期待。第一件事，我始终为了进步而努力。与其追寻全世界的骏马，不如种植丰美的草原，到时骏马自然会来。第二件事，我始终有阶段性的目标。什么东西能给我能量？答案是对未来的期待。』读到这里的时候，我便
      
                    
      • 
                    
    • C语言宏函数
                        南林yan
C语言c语言
                        
      一、什么是宏函数？通过宏定义的函数是宏函数。如下，编译器在预处理阶段会将Add(x,y)替换为((x)*(y))#defineAdd(x,y)((x)*(y))#defineAdd(x,y)((x)*(y))intmain(){inta=10;intb=20;intd=10;intc=Add(a+d,b)*2;cout<
                    
      • 
                    
    • 地推话术，如何应对地推过程中家长的拒绝
                        校师学

                        
      相信校长们在做地推的时候经常遇到这种情况：市场专员反馈家长不接单，咨询师反馈难以邀约这些家长上门，校区地推疲软，招生难。为什么？仅从地推层面分析，一方面因为家长受到的信息轰炸越来越多，对信息越来越“免疫”；而另一方面地推人员的专业能力和营销话术没有提高，无法应对家长的拒绝，对有意向的家长也不知如何跟进，眼睁睁看着家长走远；对于家长的疑问，更不知道如何有技巧地回答，机会白白流失。由于回答没技巧和专业
      
                    
      • 
                    
    • 谢谢你们，爱你们！
                        鹿游儿

                        
      昨天家人去泡温泉，二个孩子也带着去，出发前一晚，匆匆下班，赶回家和孩子一起收拾。饭后，我拿出笔和本子（上次去澳门时做手帐的本子）写下了1\2\3\4\5\6\7\8\9,让后让小壹去思考，带什么出发去旅游呢？她在对应的数字旁边画上了，泳衣、泳圈、肖恩、内衣内裤、tapuy、拖鞋……画完后，就让她自己对着这个本子，将要带的，一一带上，没想到这次带的书还是这本《便便工厂》(晚上姑婆发照片过来，妹妹累得
      
                    
      • 
                    
    • C语言如何定义宏函数？
                        小九格物
c语言
                        
      在C语言中，宏函数是通过预处理器定义的，它在编译之前替换代码中的宏调用。宏函数可以模拟函数的行为，但它们不是真正的函数，因为它们在编译时不会进行类型检查，也不会分配存储空间。宏函数的定义通常使用#define指令，后面跟着宏的名称和参数列表，以及宏展开后的代码。宏函数的定义方式：1.基本宏函数：这是最简单的宏函数形式，它直接定义一个表达式。#defineSQUARE(x)((x)*(x))2.带参
      
                    
      • 
                    
    • 微服务下功能权限与数据权限的设计与实现
                        nbsaas-boot
微服务java架构
                        
      在微服务架构下，系统的功能权限和数据权限控制显得尤为重要。随着系统规模的扩大和微服务数量的增加，如何保证不同用户和服务之间的访问权限准确、细粒度地控制，成为设计安全策略的关键。本文将讨论如何在微服务体系中设计和实现功能权限与数据权限控制。1.功能权限与数据权限的定义功能权限：指用户或系统角色对特定功能的访问权限。通常是某个用户角色能否执行某个操作，比如查看订单、创建订单、修改用户资料等。数据权限：
      
                    
      • 
                    
    • 理解Gunicorn：Python WSGI服务器的基石
                        范范0825
ipythonlinux运维
                        
      理解Gunicorn：PythonWSGI服务器的基石介绍Gunicorn，全称GreenUnicorn，是一个为PythonWSGI（WebServerGatewayInterface）应用设计的高效、轻量级HTTP服务器。作为PythonWeb应用部署的常用工具，Gunicorn以其高性能和易用性著称。本文将介绍Gunicorn的基本概念、安装和配置，帮助初学者快速上手。1.什么是Gunico
      
                    
      • 
                    
    • 小丽成长记（四十三）
                        玲玲54321

                        
      小丽发现，即使她好不容易调整好自己的心态下一秒总会有不确定的伤脑筋的事出现，一个接一个的问题，人生就没有停下的时候，小问题不断出现。不过她今天看的书，她接受了人生就是不确定的，厉害的人就是不断创造确定性，在Ta的领域比别人多的确定性就能让自己脱颖而出，显示价值从而获得的比别人多的利益。正是这样的原因，因为从前修炼自己太少，使得她现在在人生道路上打怪起来困难重重，她似乎永远摆脱不了那种无力感，有种习
      
                    
      • 
                    
    • 学点心理知识，呵护孩子健康
                        静候花开_7090

                        
      昨天听了华中师范大学教育管理学系副教授张玲老师的《哪里才是学生心理健康的最后庇护所，超越教育与技术的思考》的讲座。今天又重新学习了一遍，收获匪浅。张玲博士也注意到了当今社会上的孩子由于心理问题导致的自残、自杀及伤害他人等恶性事件。她向我们普及了一个重要的命题，她说心理健康的一些基本命题，我们与我们通常的一些教育命题是不同的，她还举了几个例子，让我们明白我们原来以为的健康并非心理学上的健康。比如如果
      
                    
      • 
                    
    • 2021年12月19日，春蕾教育集团团建活动感受——黄晓丹
                        黄错错加油

                        
      感受:1.从陌生到熟悉的过程。游戏环节让我们在轻松的氛围中得到了锻炼，也增长了不少知识。2.游戏过程中，我们贡献的是个人力量，展现的是团队的力量。它磨合的往往不止是工作的熟悉，更是观念上契合度的贴近。3.这和工作是一样的道理。在各自的岗位上，每个人摆正自己的位置、各司其职充分发挥才能，并团结一致劲往一处使，才能实现最大的成功。新知:1.团队精神需要不断地创新。过去，人们把创新看作是冒风险，现在人们
      
                    
      • 
                    
    • Cell Insight | 单细胞测序技术又一新发现，可用于HIV-1和Mtb共感染个体诊断
                        尐尐呅

                        
      结核病是艾滋病合并其他疾病中导致患者死亡的主要原因。其中结核病由结核分枝杆菌（Mycobacteriumtuberculosis,Mtb）感染引起，获得性免疫缺陷综合症（艾滋病）由人免疫缺陷病毒（Humanimmunodeficiencyvirustype1,HIV-1）感染引起。国家感染性疾病临床医学研究中心/深圳市第三人民医院张国良团队携手深圳华大生命科学研究院吴靓团队，共同研究得出单细胞测序
      
                    
      • 
                    
    • c++ 的iostream 和 c++的stdio的区别和联系
                        黄卷青灯77
c++算法开发语言iostreamstdio
                        
      在C++中，iostream和C语言的stdio.h都是用于处理输入输出的库，但它们在设计、用法和功能上有许多不同。以下是两者的区别和联系：区别1.编程风格iostream（C++风格）：C++标准库中的输入输出流类库，支持面向对象的输入输出操作。典型用法是cin（输入）和cout（输出），使用>操作符来处理数据。更加类型安全，支持用户自定义类型的输入输出。#includeintmain(){in
      
                    
      • 
                    
    • 瑶池防线
                        谜影梦蝶

                        
      冥华虽然逃过了影梦的军队，但他是一个忠臣，他选择上报战况。败给影梦后成逃兵，高层亡尔还活着，七重天失守......随便一条，即可处死冥华。冥华自然是知道以仙界高层的习性此信一发自己必死无疑，但他还选择上报实情，因为责任。同样此信送到仙宫后，知道此事的人，大多数人都认定冥华要完了，所以上到仙界高层，下到扫大街的，包括冥华自己，全都准备好迎接冥华之死。如果仙界现在还属于两方之争的话，冥华必死无疑。然而
      
                    
      • 
                    
    • 爬山后遗症
                        璃绛

                        
      爬山，攀登，一步一步走向制高点，是一种挑战。成功抵达是一种无法言语的快乐，在山顶吹吹风，看看风景，这是从未有过的体验。然而，爬山一时爽，下山腿打颤，颠簸的路，一路向下走，腿部力量不够，走起来抖到不行，停不下来了！第二天必定腿疼，浑身酸痛，坐立难安！
      
                    
      • 
                                
    • 多线程编程之join()方法
                                    周凡杨
javaJOIN多线程编程线程
                                    
      现实生活中，有些工作是需要团队中成员依次完成的，这就涉及到了一个顺序问题。现在有T1、T2、T3三个工人，如何保证T2在T1执行完后执行，T3在T2执行完后执行？问题分析：首先问题中有三个实体，T1、T2、T3， 因为是多线程编程，所以都要设计成线程类。关键是怎么保证线程能依次执行完呢？   
Java实现过程如下： 
public class T1 implements Runnabl
      
                                
      • 
                                
    • java中switch的使用
                                    bingyingao
javaenumbreakcontinue
                                    
      java中的switch仅支持case条件仅支持int、enum两种类型。 
用enum的时候，不能直接写下列形式。 
 
 
switch (timeType) {
            case ProdtransTimeTypeEnum.DAILY:

                break;

            default:
                br
      
                                
      • 
                                
    • hive having count 不能去重
                                    daizj
hive去重having count计数
                                    
      hive在使用having count()是，不支持去重计数 
  
hive (default)> select imei from t_test_phonenum where ds=20150701 group by imei having count(distinct phone_num)>1 limit 10;  
FAILED: SemanticExcep
      
                                
      • 
                                
    • WebSphere对JSP的缓存
                                    周凡杨
WAS JSP 缓存
                                    
            对于线网上的工程，更新JSP到WebSphere后，有时会出现修改的jsp没有起作用，特别是改变了某jsp的样式后，在页面中没看到效果，这主要就是由于websphere中缓存的缘故，这就要清除WebSphere中jsp缓存。要清除WebSphere中JSP的缓存，就要找到WAS安装后的根目录。 
       现服务
      
                                
      • 
                                
    • 设计模式总结
                                    朱辉辉33
java设计模式
                                    
      1.工厂模式 
  1.1 工厂方法模式 (由一个工厂类管理构造方法) 
     1.1.1普通工厂模式(一个工厂类中只有一个方法) 
     1.1.2多工厂模式(一个工厂类中有多个方法) 
     1.1.3静态工厂模式(将工厂类中的方法变成静态方法) 
&n
      
                                
      • 
                                
    • 实例：供应商管理报表需求调研报告
                                    老A不折腾
finereport报表系统报表软件信息化选型
                                    
      引言 
随着企业集团的生产规模扩张，为支撑全球供应链管理，对于供应商的管理和采购过程的监控已经不局限于简单的交付以及价格的管理，目前采购及供应商管理各个环节的操作分别在不同的系统下进行，而各个数据源都独立存在，无法提供统一的数据支持；因此，为了实现对于数据分析以提供采购决策，建立报表体系成为必须。 业务目标 
1、通过报表为采购决策提供数据分析与支撑 
2、对供应商进行综合评估以及管理，合理管理和
      
                                
      • 
                                
    • mysql
                                    林鹤霄

                                    
      转载源：http://blog.sina.com.cn/s/blog_4f925fc30100rx5l.html 
mysql -uroot -p 
ERROR 1045 (28000): Access denied for user 'root'@'localhost' (using password: YES) 
  
[root@centos var]# service mysql
      
                                
      • 
                                
    • Linux下多线程堆栈查看工具(pstree、ps、pstack)
                                    aigo
linux
                                    
      原文：http://blog.csdn.net/yfkiss/article/details/6729364 
  
1. pstree 
pstree以树结构显示进程$ pstree -p work | grep adsshd(22669)---bash(22670)---ad_preprocess(4551)-+-{ad_preprocess}(4552)  &n
      
                                
      • 
                                
    • html input与textarea 值改变事件
                                    alxw4616
JavaScript
                                    
      // 文本输入框(input) 文本域(textarea)值改变事件 
// onpropertychange(IE) oninput(w3c) 
$('input,textarea').on('propertychange input', function(event) { 
     console.log($(this).val()) 
}); 
  
      
                                
      • 
                                
    • String类的基本用法
                                    百合不是茶
String
                                    
        
字符串的用法; 
    // 根据字节数组创建字符串 
byte[] by = { 'a', 'b', 'c', 'd' };
String newByteString = new String(by); 
  
  
    1,length()  获取字符串的长度 
  
  &nbs
      
                                
      • 
                                
    • JDK1.5 Semaphore实例
                                    bijian1013
javathreadjava多线程Semaphore
                                    
      Semaphore类 
       一个计数信号量。从概念上讲，信号量维护了一个许可集合。如有必要，在许可可用前会阻塞每一个 acquire()，然后再获取该许可。每个 release() 添加一个许可，从而可能释放一个正在阻塞的获取者。但是，不使用实际的许可对象，Semaphore 只对可用许可的号码进行计数，并采取相应的行动。 
S
      
                                
      • 
                                
    • 使用GZip来压缩传输量
                                    bijian1013
javaGZip
                                    
              启动GZip压缩要用到一个开源的Filter：PJL Compressing Filter。这个Filter自1.5.0开始该工程开始构建于JDK5.0，因此在JDK1.4环境下只能使用1.4.6。 
        PJL Compressi
      
                                
      • 
                                
    • 【Java范型三】Java范型详解之范型类型通配符
                                    bit1129
java
                                    
        
  
定义如下一个简单的范型类， 
  
package com.tom.lang.generics;

public class Generics<T> {
    private T value;
    public Generics(T  value) {
        this.value = value;
    }
} 
      
                                
      • 
                                
    • 【Hadoop十二】HDFS常用命令
                                    bit1129
hadoop
                                    
      1. 修改日志文件查看器 
  
hdfs oev -i edits_0000000000000000081-0000000000000000089 -o edits.xml
cat edits.xml 
  
修改日志文件转储为xml格式的edits.xml文件，其中每条RECORD就是一个操作事务日志 
  2. fsimage查看HDFS中的块信息等 
&nb
      
                                
      • 
                                
    • 怎样区别nginx中rewrite时break和last
                                    ronin47

                                    
      在使用nginx配置rewrite中经常会遇到有的地方用last并不能工作，换成break就可以，其中的原理是对于根目录的理解有所区别，按我的测试结果大致是这样的。  
 
 location /    
 {     
     proxy_pass http://test; 
      
                                
      • 
                                
    • java-21.中兴面试题 输入两个整数 n 和 m ，从数列 1 ， 2 ， 3.......n 中随意取几个数 , 使其和等于 m
                                    bylijinnan
java
                                    
      
import java.util.ArrayList;
import java.util.List;
import java.util.Stack;

public class CombinationToSum {

	/*
第21 题
2010 年中兴面试题
编程求解：
输入两个整数 n 和 m ，从数列 1 ， 2 ， 3.......n 中随意取几个数 ,
使其和等
      
                                
      • 
                                
    • eclipse svn 帐号密码修改问题
                                    开窍的石头
eclipseSVNsvn帐号密码修改
                                    
      问题描述： 
     Eclipse的SVN插件Subclipse做得很好，在svn操作方面提供了很强大丰富的功能。但到目前为止，该插件对svn用户的概念极为淡薄，不但不能方便地切换用户，而且一旦用户的帐号、密码保存之后，就无法再变更了。 
解决思路： 
     删除subclipse记录的帐号、密码信息，重新输入
      
                                
      • 
                                
    • [电子商务]传统商务活动与互联网的结合
                                    comsci
电子商务
                                    
       
 
      某一个传统名牌产品，过去销售的地点就在某些特定的地区和阶层，现在进入互联网之后，用户的数量群突然扩大了无数倍，但是，这种产品潜在的劣势也被放大了无数倍，这种销售利润与经营风险同步放大的效应，在最近几年将会频繁出现。。。。 
 
       如何避免销售量和利润率增加的
      
                                
      • 
                                
    • java 解析 properties-使用 Properties-可以指定配置文件路径
                                    cuityang
javaproperties
                                    
      #mq 
xdr.mq.url=tcp://192.168.100.15:61618; 
 
import java.io.IOException; 
import java.util.Properties; 
 
 
public class Test { 
 
 String conf = "log4j.properties"; 
 private static final
      
                                
      • 
                                
    • Java核心问题集锦
                                    darrenzhu
java基础核心难点
                                    
      注意，这里的参考文章基本来自Effective Java和jdk源码 
 
 
1)ConcurrentModificationException 
当你用for each遍历一个list时，如果你在循环主体代码中修改list中的元素，将会得到这个Exception，解决的办法是： 
1)用listIterator, 它支持在遍历的过程中修改元素， 
2)不用listIterator, new一个
      
                                
      • 
                                
    • 1分钟学会Markdown语法
                                    dcj3sjt126com
markdown
                                    
      markdown 简明语法 基本符号 
 
 *,-,+ 3个符号效果都一样，这3个符号被称为 Markdown符号  
 空白行表示另起一个段落 
 `是表示inline代码，tab是用来标记 代码段，分别对应html的code，pre标签 
 换行 
 
 单一段落( <p>) 用一个空白行 
 连续两个空格 会变成一个 <br> 
 连续3个符号，然后是空行
      
                                
      • 
                                
    • Gson使用二（GsonBuilder）
                                    eksliang
jsongsonGsonBuilder
                                    
      转载请出自出处：http://eksliang.iteye.com/blog/2175473 一.概述 
    GsonBuilder用来定制java跟json之间的转换格式 
  二.基本使用 
实体测试类： 
温馨提示：默认情况下@Expose注解是不起作用的,除非你用GsonBuilder创建Gson的时候调用了GsonBuilder.excludeField
      
                                
      • 
                                
    • 报ClassNotFoundException: Didn't find class "...Activity" on path: DexPathList
                                    gundumw100
android
                                    
      有一个工程，本来运行是正常的，我想把它移植到另一台PC上，结果报： 
 
 java.lang.RuntimeException: Unable to instantiate activity ComponentInfo{com.mobovip.bgr/com.mobovip.bgr.MainActivity}: java.lang.ClassNotFoundException: Didn't f
      
                                
      • 
                                
    • JavaWeb之JSP指令
                                    ihuning
javaweb
                                    
        
要点 
  
JSP指令简介  
page指令  
include指令  
  
JSP指令简介  
  
JSP指令（directive）是为JSP引擎而设计的，它们并不直接产生任何可见输出，而只是告诉引擎如何处理JSP页面中的其余部分。 
JSP指令的基本语法格式： 
<%@ 指令 属性名="
      
                                
      • 
                                
    • mac上编译FFmpeg跑ios
                                    啸笑天
ffmpeg
                                    
      1、下载文件：https://github.com/libav/gas-preprocessor， 复制gas-preprocessor.pl到/usr/local/bin/下， 修改文件权限：chmod 777 /usr/local/bin/gas-preprocessor.pl 
2、安装yasm-1.2.0 
curl http://www.tortall.net/projects/yasm
      
                                
      • 
                                
    • sql mysql oracle中字符串连接
                                    macroli
oraclesqlmysqlSQL Server
                                    
      有的时候，我们有需要将由不同栏位获得的资料串连在一起。每一种资料库都有提供方法来达到这个目的： 
 
 MySQL: CONCAT() 
 Oracle: CONCAT(), || 
 SQL Server: + 
 
CONCAT() 的语法如下： 
Mysql 中 CONCAT(字串1, 字串2, 字串3, ...): 将字串1、字串2、字串3，等字串连在一起。 
请注意，Oracle的CON
      
                                
      • 
                                
    • Git fatal: unab SSL certificate problem: unable to get local issuer ce rtificate
                                    qiaolevip
学习永无止境每天进步一点点git纵观千象
                                    
      // 报错如下： 
$ git pull origin master 
fatal: unable to access 'https://git.xxx.com/': SSL certificate problem: unable to get local issuer ce 
rtificate 
  
// 原因： 
由于git最新版默认使用ssl安全验证，但是我们是使用的git未设
      
                                
      • 
                                
    • windows命令行设置wifi
                                    surfingll
windowswifi笔记本wifi
                                    
      还没有讨厌无线wifi的无尽广告么，还在耐心等待它慢慢启动么 
教你命令行设置 笔记本电脑wifi： 
 
1、开启wifi命令 
 

netsh wlan set hostednetwork mode=allow ssid=surf8 key=bb123456
netsh wlan start hostednetwork
pause
 
 其中pause是等待输入，可以去掉 
 
2、
      
                                
      • 
                                
    • Linux（Ubuntu）下安装sysv-rc-conf
                                    wmlJava
linuxubuntusysv-rc-conf
                                    
      安装：sudo apt-get install sysv-rc-conf 使用：sudo sysv-rc-conf 
操作界面十分简洁，你可以用鼠标点击，也可以用键盘方向键定位，用空格键选择，用Ctrl+N翻下一页，用Ctrl+P翻上一页，用Q退出。 
  
  
背景知识 
sysv-rc-conf是一个强大的服务管理程序，群众的意见是sysv-rc-conf比chkconf
      
                                
      • 
                                
    • svn切换环境，重发布应用多了javaee标签前缀
                                    zengshaotao
javaee
                                    
      更换了开发环境，从杭州，改变到了上海。svn的地址肯定要切换的，切换之前需要将原svn自带的.svn文件信息删除，可手动删除，也可通过废弃原来的svn位置提示删除.svn时删除。 
  
然后就是按照最新的svn地址和规范建立相关的目录信息，再将原来的纯代码信息上传到新的环境。然后再重新检出，这样每次修改后就可以看到哪些文件被修改过，这对于增量发布的规范特别有用。 
  
检出
      
                                
      •