周一到周六每天一题，你对了几个？

周一，for和foreach你喜欢用哪个？

public static void removeFor() {
    List<Integer> list = new ArrayList<>(Arrays.asList(1, 2, 3, 4));
    for (int i = 0; i < list.size(); i++) {
        list.remove(list.get(i));
    }
    System.out.println(list);
}

public static void removeForeach() {
    List<Integer> list = new ArrayList<>(Arrays.asList(1, 2, 3, 4));
    for (Integer integer : list) {
        list.remove(integer);
    }
    System.out.println(list);
}

问: 上面两个输出是什么？这两种有什么区别？
答:
第一个问题其实是没什么意义的，删除元素，不可能这么删除，只是用来区别for和foreach的。
[2, 4] 和 ConcurrentModificationException 异常
第二个问题
foreach遍历集合类型和数组类型底层实现的不同

• 1.集合类型的遍历本质是使用迭代器实现的
• 2.数组的遍历是通过for循环来实现的

两者的对比
for 灵活，但是不是阅读性差
foreach 阅读性好性能要分为两种
ArrayList for大于foreach
LinkedList foreach大于for
它们的对比等等还有许多对于我而言，我更喜欢foreach

周二，坑爹的字段(老项目遗留字段的烦恼)

@RestController
public class Test {
  //第一种 端口是8080
  @GetMapping("test")
  public Demo test(){
    Demo demo = new Demo();
    demo.setXID("1");
    demo.setXName("420路");
    demo.setPowerWord("123456");
    return demo;
  }
  
  //第二种 
  public static void main(String[] args) {
    Demo demo = new Demo();
    demo.setXID("1");
    demo.setXName("420路");
    demo.setPowerWord("123456");
    RestTemplate restTemplate = new RestTemplate();
    String s = restTemplate.postForObject("xxx", demo, String.class);
  }

  @Data
  static class Demo{
    private String XID;
    private String XName;
    private String powerWord;
  }
}

示例:

//此项目是IDEA自动生成的Springboot项目
//如果你觉得都是这个，请把这个写在下面，
//不是的话，写出你的理解，或者怎么才能得到下面的结果
{"powerWord":"123456","XID":"123",
"XName":"420路"}

问: 写出别人请求我得到的和我请求别人别人收到的Json字符串是什么？根据示例改写。
答:
此题答案是

{"powerWord":"123456","xid":"123","xname":"420路"}

要想得到

{"powerWord":"123456","XID":"123","XName":"420路"}

的话需要

@JsonProperty("XID")
private String XID;

其余的也同理

周三，一道面试题考验了你对Java的理解程度

public static void main(String[] args) {
    Integer a = 4;
    Integer b = 2;
    System.out.printf("a = %s, b = %s\n", a, b);
    //交换a和b的值
    swap(a, b);
    System.out.printf("a = %s, b = %s\n", a, b);
}

public static void swap(Integer a, Integer b) {
    // TODO 实现
}

问: 请补全上面代码，实现交换a，b的值。
答:
要解决这个问题要知道
值传递: 传递的是实际值，像基本数据类型
引用传递: 将对象的引用作为实参进行传递
有可能你会建一个临时变量temp 作为交换两个的值
或者用^的办法，但是最后得到的结果都是错误的。
其实这个考察的是java的反射以及Integer的127和128的鸿沟
具体代码如下

public static void swap(Integer a, Integer b) { 
    int temp = a.intValue(); 
    try { 
        Field value = Integer.class.getDeclaredField("value"); 
        value.setAccessible(true);        value.set(a, b); 
        value.set(b, new Integer(temp)); 
     } catch (NoSuchFieldException e) { 
        e.printStackTrace(); 
     } catch (IllegalAccessException e) { 
        e.printStackTrace(); 
     }
}

周四，小编别哭！！！

public static void main(String[] args) {
    System.out.println(test());
}

public static String test() {
    String ret = "";
    try{
        throw new Exception();
    }
    catch(Exception e){
        ret = "大哭";
        System.out.println("小编");
        return ret;
    }
    finally{
        ret = "非常大的大哭";
        System.out.println("没题目了");
    }
}

问: 请写出上面输出的结果
答:
正确答案是
小编没题目了大哭
会先走到return但是不会返回，而是把值存放起来，
走完finally才会把存的值返回出去。

周五，这个会了，我觉得你Java8 lambda可以毕业了。

@Data
@Builder
static class Order{

  private  Integer id;
  //用户名称
  private String userName;
  //商品名称
  private String productName;

}

public static void main(String[] args) {
  Order order1 = Order.builder().id(1).userName("zy").productName("小鱼").build();
  Order order2 = Order.builder().id(2).userName("ss").productName("小虾").build();
  Order order3 = Order.builder().id(3).userName("zy").productName("小虾").build();
  Order order4 = Order.builder().id(4).userName("zy").productName("小鱼").build();
  Order order5 = Order.builder().id(4).userName("ss").productName("小虾").build();

  //所有订单
  List<Order> orderList = new ArrayList<>(Arrays.asList(order1, order2, order3, order4, order5));
  //现在小鱼只能和小鱼在一起，小虾只能和小虾在一起，
  //所以要打包几个订单
  //意思就是名字是zy，商品是小鱼只能出现一次，算一个包裹
  //请用一句代码写出来，当然要输出List哦
  //此题list最后大小是3
  //分别是 zy小鱼，ss小虾，zy小虾
  List<Order> collect =
        
}

问: 一句话，解决双层去重
答:
第一种

List<Order> collect = 
  orderList
    .stream()
    .collect(Collectors
        .collectingAndThen(Collectors
            .toCollection(() -> new TreeSet<>(Comparator
                .comparing(s -> s.getUserName() + s.getProductName()))), ArrayList::new));

第二种

List<Order> collect = 
    orderList
        .stream()
        .collect(Collectors
            .groupingBy(order -> "u:" + order.getUserName() + "p:" + order.getProductName()))
            .values()
            .stream()
            .map(list-> list.get(0))
            .collect(Collectors.toList());

周六，周六休息一下，这道题反正我不行，你行吗？

现在有2杯水。一杯13升，一杯7升。
另外有一个19升的空杯子。如何倒出2杯10升的水。

问: 转动你的小脑瓜子，来解答这一题
答:
(0,13,7)->(13,0,7)->(19,0,1)->(19,1,0)->(12,1,7)->(12,8,0)->(5,8,7)->(5,13,2)->(18,0,2)->(18,2,0)->(11,2,7)->(11,9,0)->(4,9,7)->(4,13,3)->(17,0,3)->(17,3,0)->(10,3,7)->(10,10,0)