发表于 | 分类于 |
字数统计: | 阅读时长 ≈

java版本：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
public static void main(String[] args) {
    System.out.println(isPalindrome_Double_Direction(-121));
}

  //根据0007 Reverse_integer的经验 讲整数逆序与原整数比较大小
  public static boolean isPalindrome(int x) {
    if( x < 0) return false;
    if( x < 10) return true;

    if (x % 10 == 0) return false;

    int n = 0,init = x;
    while(x != 0){
        n = n * 10 + x % 10;
        x = x / 10;
    }

    return init == n;
  }

  //回文序列检查
  public static boolean isPalindrome_Double_Direction(int x) {
      if( x < 0){
          return false;
      }
      char[] ArrX = String.valueOf(x).toCharArray();
      int middleIndex = ArrX.length / 2 - 1;
      for(int i = 0; i <= middleIndex;i++){
          if(ArrX[i] != ArrX[ArrX.length-1-i])
              return false;
      }
      return true;
  }

发表于 | 分类于 |
字数统计: | 阅读时长 ≈

java版本：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
public static void main(String[] args) {

    System.out.println(reverse_plus(-123));

}


  // 数字转字符数组 ===>倒叙，再转数字
  public static int reverse(int x) {

    String strX = "";
    boolean flag = false;
    if(x < 0){
        x = -x;
        flag = true;
    }

      strX += x;
      char[] ArrX = strX.toCharArray();
      strX = "";
      for (int i = ArrX.length-1; i >=0; i--){
          strX += ArrX[i];
      }

      try{
          return  flag? -Integer.parseInt(strX):Integer.parseInt(strX);
      }catch (NumberFormatException e){
          return 0;
      }
  }

  //纯数字游戏  倒着数数
  public static int reverse_plus(int x) {

    long n = 0;
    while (x!=0){
        n = n * 10 + x%10;
        x = x / 10;
    }
    return (int)n == n? (int) n : 0;

  }

发表于 | 分类于 |
字数统计: | 阅读时长 ≈

java版本：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
 public static void main(String[] args) {
    int[] nums = {-1,-2,-3,-4,-5};
    int[] sum = twoSum(nums, -8);
    System.out.println(Arrays.toString(sum));
  }

//方法一，暴力破解 试图用过滤条件减少循环次数 为什么不换一种方式？
 public static int[] twoSum(int[] nums, int target) {

    int[] reNums = new int[2];
    for (int i = 0; i < nums.length;i++) {
        //if(target - nums[i] >= 0){
          for (int j = i + 1; j < nums.length; j++) {
              //if(target -nums[i] - nums[j] < 0) continue;
              if((nums[i] + nums[j]) == target){
                  reNums[0] = i;
                  reNums[1] = j;
                  break;
              }
          }
        //}
    }
    return reNums;
}
//第二种方式：哈希表 HashMap
 public static int[] twoSum_hash(int[] nums, int target) {
        Map<Integer,Integer> map = new HashMap<>();
        for (int i = 0; i < nums.length; i++) {
            int tempR = target - nums[i];
           if(map.containsKey(tempR)){
               return new int[]{map.get(tempR),i};
           }
           map.put(nums[i],i);
        }
        return null;
  }

发表于 | 分类于 |
字数统计: | 阅读时长 ≈

Lambda表达式的基础语法：

Lambda表达式需要“函数式接口”的支持；

函数式接口：接口中只有一个抽象方法的接口，称为函数式的接口，可以使用注解@FunctionalInterface 修饰，用来检查是否是函数式接口

Java8引入的一个新的操作符 “->” 该操作符成为箭头操作符或者Lambda操作符，该操作符将Lam表达表达式分为两个部分：

左侧：Lambda 表达式的参数列表 -> 右侧：Lambda 表达式中所需执行的功能 即Lambda体

Lambda的语法格式
语法格式一：无参数，无返回值
1
2
3
4
5
6
7
8
9
10
11
12
13
Runnable rb = new Runnable()
 {
     @Override
     public void run()
     {
         System.out.println("匿名内部类");
     }
 };

 rb.run();

 Runnable rab = () -> System.out.println("Hello Lambda");
 rab.run();
语法格式二：有一个参数，无返回值 ,如果有一个参数，参数的括号可以不写
1
2
3
4
5
Consumer<String> com = (x) -> System.out.println(x);
com.accept("I AM Consumer");
//参数不带括号
Consumer<String> com = x -> System.out.println(x);
com.accept("I AM Consumer");
语法格式三：有两个以上的参数，有返回值，并且Lambda体中有多条语句，多条语句用{}括起来
1
2
3
4
Comparator<Integer> com = (x,y) -> {
    System.out.println("我有两个参数和多条语句");
    return Integer.compare(x,y);
};
语法格式四：若Lambda体中只有一条语句，return 和 大括号都可以不写
1
Comparator<Integer> com = (x,y) ->  Integer.compare(x,y);
语法格式五：Lambda表达式的参数列表的数据类型可以写，因为JVM编译器可以根据上下文推断出参数的数据类型，即“类型推断”
Java8 内置的四大核心函数式接口
1
2
3
4
5
6
7
8
Consumer<T>:消费型接口
    void accept(T t)
Supplier<T>:供给型接口
    T get()
Function<T,R>: 函数型接口
    R apply(T t)
Predicate<T>: 断言型接口
    boolean test(T t)
方法引用：如果Lambda 体中的有方法已经实现了，我们可以使用“方法引用”(可以理解为方法引用是Lambda表达式的另一种表现形式)

三种语法格式：对象::实例方法名 类::静态方法名 类::实例方法名

引用方法的参数列表和返回值要和函数式接口的一致

如果Lambda参数列表中的第一个参数时实例方法的调用者，而第二个参数时实例方法的参数时，可以使用ClassName::MethodName( 类 : : 实例方法名)

1
2
3
4
5
6
7
8
      //对象::实例方法名
      Consumer<String> consumer = System.out::println;
//类::静态方法名
      consumer.accept("方法引用");
      Comparator<Integer> com = Integer::compare;
//类::实例方法名
      BiConsumer<String,String> bp = (x,y) ->x.equals(y);
      BiConsumer<String,String> bp2 = String::equals;
构造器引用 格式：ClassName::new

需要调用的构造器的参数列表要与函数式接口中抽象方法的参数列表保持一致

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
public class Person
{
    private int age;
    private String name;
    private int high;

    public Person()
    {
    }

    public Person(int age, String name)
    {
        this.age = age;
        this.name = name;
    }

    public Person(int age, String name, int high)
    {
        this.age = age;
        this.name = name;
        this.high = high;
    }
}
//调用无参构造器创建对象
Supplier<Person> fun1 = () -> new Person();
Person person = fun1.get();
Supplier<Person> fun2 = Person::new;
Person person2 = fun2.get();
//调用一个参数创建对象
Function<Integer,Person> fun3 = Person::new;
Person person3 = fun3.apply(12);
//调用两个参数创建对象
BiFunction<Integer,String,Person> fun4 = Person::new;
Person person4 = fun4.apply(12,"HHH");
数组引用：Type[]::new
1
2
3
4
5
      Function<Integer,String[]> fun5 = (x) -> new String[x];
      String[] strs = fun5.apply(10);
//数组引用
      Function<Integer,String[]> fun6 = String[]::new;
      String[] strs2 = fun6.apply(10);