Home

class Solution {
    public int[] singleNumbers(int[] nums) {
        int sum = 0, min = Integer.MAX_VALUE, max = Integer.MIN_VALUE, zeroCount = 0;
        for (int num : nums) {
            if (num == 0) {
                zeroCount += 1;
            }
            min = Math.min(min, num);
            max = Math.max(max, num);
            sum ^= num;
        }
        // 需要特判一下某个数是0的情况。
        if (zeroCount == 1) {
            return new int[]{sum, 0};
        }
        int lo = min, hi = max;
        while (lo <= hi) {
            // 根据 lo 的正负性来判断二分位置怎么写，防止越界。
            int mid = lo < 0 ? lo + hi >> 1 : lo + (hi - lo) / 2;
            int loSum = 0, hiSum = 0;
            for (int num : nums) {
                if (num <= mid) {
                    loSum ^= num;
                } else {
                    hiSum ^= num;
                }
            }
            if (loSum != 0 && hiSum != 0) {
                // 两个都不为0，说明 p 和 q 分别落到2个数组里了。
                return new int[]{loSum, hiSum};
            }
            if (loSum == 0) {
                // 说明 p 和 q 都比 mid 大，所以比 mid 小的数的异或和变为0了。
                lo = mid;
            } else {
                // 说明 p 和 q 都不超过 mid
                hi = mid;
            }
        }
        // 其实如果输入是符合要求的，程序不会执行到这里，为了防止compile error加一下
        return null;
    }
}

Hibernate: SELECT me.address as address,me.totalChecked as totalChecked,info.checked as checked,me.avatar as avatar,info.checkedTime as checkedTime,info.upvoteNumber as upvoteNumber,me.username as username FROM Member me LEFT  JOIN  (SELECT * FROM CheckDayInfo  WHERE date= ? ) info  ON me.username=info.username WHERE me.status= 0 ORDER by info.checked DESC , info.checkedTime DESC limit ?
Hibernate: select COUNT(*) FROM Member me LEFT  JOIN  (SELECT * FROM CheckDayInfo  WHERE  date= ? ) info  ON me.username=info.username WHERE me.status= 0
2020-04-21 01:49:27.398 ERROR 56349 --- [p-nio-80-exec-1] c.o.b.c.handler.GlobalExceptionHandler   : [everyday]-[unknown error happen]-No converter found capable of converting from type [org.springframework.data.jpa.repository.query.AbstractJpaQuery$TupleConverter$TupleBackedMap] to type [com.ojeveryday.backend.pojo.dto.CheckDayVO]

org.springframework.core.convert.ConverterNotFoundException: No converter found capable of converting from type [org.springframework.data.jpa.repository.query.AbstractJpaQuery$TupleConverter$TupleBackedMap] to type [com.ojeveryday.backend.pojo.dto.CheckDayVO]

public interface JpaSpecificationExecutor<T> {

    T findOne(Specification<T> spec);//根据sql获取单个对象数据

    List<T> findAll(Specification<T> spec);//根据sql查询所有数据

    Page<T> findAll(Specification<T> spec, Pageable pageable);//根据sql分页查询数据

    List<T> findAll(Specification<T> spec, Sort sort); //根据sql查询数据，并根据参数进行排序

    long count(Specification<T> spec); //根据sql查询数据总数
}

//可以输入多个Sort.Order对象，在进行多个值排序时有用
public Sort(Sort.Order... orders);

//和上面的方法一样，无非把多个参数换成了一个List
public Sort(List orders);

//当排序方向固定时，使用这个比较方便，第一个参数是排序方向，第二个开始就是排序的字段.
public Sort(Sort.Direction direction, String... properties);

//第一个参数是排序方向,还有一个方法第二个参数是list，原理相同
public Sort(Direction direction, List<String> properties);

int getPageNumber();

int getPageSize();

int getOffset();

Sort getSort();

Pageable next();

Pageable previousOrFirst();

Pageable first();

boolean hasPrevious();

//这个构造方法构造出来的分页对象不具备排序功能
public PageRequest(int page, int size) {
    this(page, size, (Sort)null);
}
//Direction和properties用来做排序操作
public PageRequest(int page, int size, Direction direction, String... properties) {
    this(page, size, new Sort(direction, properties));
}
//此构造方法是自定义一个排序的操作
public PageRequest(int page, int size, Sort sort) {
    super(page, size);
    this.sort = sort;
}

Specification<User> specification = new Specification<User>(){

    @Override
    public Predicate toPredicate(Root<MessageItem> root, CriteriaQuery<?> query, CriteriaBuilder cb){
    List<Predicate> predicates = new ArrayList<Predicate>();
    //root.get("name")表示获取name这个字段名称,like表示执行like查询,%zt%表示值
    Predicate p1 = cb.like(root.get("name"), "%ray%");
    Predicate p2 = cb.greaterThan(root.get("rid"),"3");
    //将两个查询条件联合起来之后返回Predicate对象
     //建立子查询
     //构建criteriaQuery对象
    CriteriaQuery<Organization> criteriaQuery  = cb.createQuery(Organization.class);
    //获取子查询Subquery对象
    Subquery<Organization> organizationSubQuery = criteriaQuery.subquery(Organization.class);
    //构建新的子查询字段Mapping对象
    Root<Organization> organizationSubRoot =         organizationubQuery.from(Organization.class);
    //相当于sql中的select *，如需获取一个字段可以使用organizationSubRoot.get("字段").as(String.class).
    organizationSubQuery.select(organizationSubRoot);
    Predicate subqueryPredicate = cb.and(cb.equal(organizationSubRoot .get("rid").as(String.class), root.get("rid").as(String.class),
    cb.equal(organizationSubRoot .get("orgName").as(String.class),"部门名称"))；
    //构建where条件
    organizationSubQuery .where(subqueryPredicate);
    // exists的使用
    Predicate p3 = cb.exists(organizationSubQuery);
    //相当于select rid,name...
    query.multiselect(root.get("rid"),root.get("name"));
    Predicate p4 = cb.and(p1,p2,p3);
    predicates.add(p4)
    return query.where(predicates.toArray(new     Predicate[predicates.size()])).getRestriction();

    }
};

Order order = new Order(Direction.ASC,"name");
Sort sort = new Sort(order);
Pageable pageable = new PageRequest(page,size,sort);//page从0开始
Page<User> resutls = UserDao.findAll(specification, pageable);

//第一个Specification定义了两个or的组合
Specification s1 = new Specification() {
    @Override
    public Predicate toPredicate(Root root, CriteriaQuery criteriaQuery, CriteriaBuilder criteriaBuilder) {
        Predicate p1 = criteriaBuilder.equal(root.get("rid"),"2");
        Predicate p2 = criteriaBuilder.equal(root.get("rid"),"3");
        return criteriaBuilder.or(p1,p2);
    }
};
//第二个Specification定义了两个or的组合
Specification s2 = new Specification() {
    @Override
    public Predicate toPredicate(Root root, CriteriaQuery criteriaQuery, CriteriaBuilder criteriaBuilder) {
        Predicate p1 = criteriaBuilder.like(root.get("name"),"r%");
        Predicate p2 = criteriaBuilder.like(root.get("name"),"a%");
        return criteriaBuilder.or(p1,p2);
    }
};
//通过Specifications将两个Specification连接起来，第一个条件加where，第二个是and
List userList= UserDao.findAll(Specifications.where(s1).and(s2));

import java.util.Arrays;

public class Solution {

    // 选择排序：每一轮选择最小元素交换到未排定部分的开头

    public int[] sortArray(int[] nums) {
        int len = nums.length;
        // 循环不变量：[0, i) 有序，且该区间里所有元素就是最终排定的样子
        for (int i = 0; i < len - 1; i++) {
            // 选择区间 [i, len - 1] 里最小的元素的索引，交换到下标 i
            int minIndex = i;
            for (int j = i + 1; j < len; j++) {
                if (nums[j] < nums[minIndex]) {
                    minIndex = j;
                }
            }
            swap(nums, i, minIndex);
        }
        return nums;
    }

    private void swap(int[] nums, int index1, int index2) {
        int temp = nums[index1];
        nums[index1] = nums[index2];
        nums[index2] = temp;
    }

    public static void main(String[] args) {
        int[] nums = {5, 2, 3, 1};
        Solution solution = new Solution();
        int[] res = solution.sortArray(nums);
        System.out.println(Arrays.toString(res));
    }
}

public class Solution {

    // 插入排序：稳定排序，在接近有序的情况下，表现优异

    public int[] sortArray(int[] nums) {
        int len = nums.length;
        // 循环不变量：将 nums[i] 插入到区间 [0, i) 使之成为有序数组
        for (int i = 1; i < len; i++) {
            // 先暂存这个元素，然后之前元素逐个后移，留出空位
            int temp = nums[i];
            int j = i;
            // 注意边界 j > 0
            while (j > 0 && nums[j - 1] > temp) {
                nums[j] = nums[j - 1];
                j--;
            }
            nums[j] = temp;
        }
        return nums;
    }
}