Java基础语法_Day13

一、API概述
  • API概念

API(Application Programming Interface) : 应用程序编程接口
编写一个机器人程序去控制机器人踢足球，程序就需要向机器人发出向前跑、向后跑、射门、抢球等各种命令，没有编过程序的人很难想象这样的程序如何编写。但是对于有经验的开发人员来说，知道机器人厂商一定会提供一些用于控制机器人的Java类，这些类中定义好了操作机器人各种动作的方法。其实，这些Java类就是机器人厂商提供给应用程序编程的接口，大家把这些类称为API。本章涉及的Java API指的就是JDK中提供的各种功能的Java类。

  • 快速使用API步骤:

A:打开帮助文档
B:点击显示，找到索引，看到输入框
C:你要学习什么内容，你就在框框里面输入什么内容
举例：Random
D:看包
java.lang包下的类在使用的时候是不需要导包的
E:看类的描述
Random类是用于生成随机数的类
F:看构造方法
Random():无参构造方法
Random r = new Random();
G:看成员方法
public int nextInt(int n):产生的是一个[0,n)范围内的随机数
调用方法：
看返回值类型：人家返回什么类型，你就用什么类型接收
看方法名：名字不要写错了
看形式参数：人家要几个参数，你就给几个，人家要什么数据类型的，你就给什么数据类型的
int number = r.nextInt(100);

二、Scanner类 与 String类
  • Scanner类
  • Scanner类作用
    用Scanner类的方法可以完成接收键盘录入的数据
  • Scanner类接受键盘录入的字符串
  • 案例代码一:
package com.neuedu.demo;
import java.util.Scanner;
/*
* Scanner:用于获取键盘录入的数据。(基本数据类型，字符串数据)
* public String nextLine():获取键盘录入的字符串数据
*/
public class ScannerDemo {
  public static void main(String[] args) {
      //创建键盘录入对象
      Scanner sc = new Scanner(System.in);
      //接收数据
      System.out.println("请输入一个字符串数据：");
      String s = sc.nextLine();
      
      //输出结果
      System.out.println("s:"+s);
  }
}
  • String类
  • String类概述
    通过JDK提供的API，查看String类的说明
    A:"abc"是String类的一个实例,或者成为String类的一个对象
    B:字符串字面值"abc"也可以看成是一个字符串对象
    C:字符串是常量，一旦被赋值，就不能被改变
    D:字符串本质是一个字符数组
  • String类的构造方法
    String(String original):把字符串数据封装成字符串对象
    String(char[] value):把字符数组的数据封装成字符串对象
    String(char[] value, int index, int count):把字符数组中的一部分数据封装成字符串对象
  • 常用构造方法演示
  • 案例代码二:
package com.neuedu.demo;
/*
* String:字符串类
*         由多个字符组成的一串数据
*         字符串其本质是一个字符数组
* 
* 构造方法：
*         String(String original):把字符串数据封装成字符串对象
*         String(char[] value):把字符数组的数据封装成字符串对象
*         String(char[] value, int index, int count):把字符数组中的一部分数据封装成字符串对象
* 
* 注意：字符串是一种比较特殊的引用数据类型，直接输出字符串对象输出的是该对象中的数据。
*/
public class StringDemo {
  public static void main(String[] args) {
      //方式1
      //String(String original):把字符串数据封装成字符串对象
      String s1 = new String("hello");
      System.out.println("s1:"+s1);
      System.out.println("---------");
      
      //方式2
      //String(char[] value):把字符数组的数据封装成字符串对象
      char[] chs = {'h','e','l','l','o'};
      String s2 = new String(chs);
      System.out.println("s2:"+s2);
      System.out.println("---------");
      
      //方式3
      //String(char[] value, int index, int count):把字符数组中的一部分数据封装成字符串对象
      //String s3 = new String(chs,0,chs.length);
      String s3 = new String(chs,1,3);
      System.out.println("s3:"+s3);
      System.out.println("---------");
      
      //方式4
      String s4 = "hello";
      System.out.println("s4:"+s4);
  }
}
  • 创建字符串对象两种方式的区别

  • 案例代码三:


    内存图.png
package com.neuedu.demo;
/*
* 通过构造方法创建的字符串对象和直接赋值方式创建的字符串对象有什么区别呢?
*         通过构造方法创建字符串对象是在堆内存。
*         直接赋值方式创建对象是在方法区的常量池。
*         
* ==:
*         基本数据类型：比较的是基本数据类型的值是否相同
*         引用数据类型：比较的是引用数据类型的地址值是否相同
*/
public class StringDemo2 {
  public static void main(String[] args) {
      String s1 = new String("hello");
      String s2 = "hello";
      
      System.out.println("s1:"+s1);
      System.out.println("s2:"+s2);
      
      System.out.println("s1==s2:"+(s1==s2)); //false
      
      String s3 = "hello";
      System.out.println("s1==s3:"+(s1==s3)); //false
      System.out.println("s2==s3:"+(s2==s3)); //true
  }
}
  • String类的判断功能
    boolean equals(Object obj):比较字符串的内容是否相同
    boolean equalsIgnoreCase(String str):比较字符串的内容是否相同,忽略大小写
    boolean startsWith(String str):判断字符串对象是否以指定的str开头
    boolean endsWith(String str):判断字符串对象是否以指定的str结尾
  • 判断方法演示
  • 案例代码四:
package com.neuedu.demo;
/*
* Object:是类层次结构中的根类，所有的类都直接或者间接的继承自该类。
* 如果一个方法的形式参数是Object，那么这里我们就可以传递它的任意的子类对象。
* 
* String类的判断功能：
* boolean equals(Object obj):比较字符串的内容是否相同
* boolean equalsIgnoreCase(String str):比较字符串的内容是否相同,忽略大小写
* boolean startsWith(String str):判断字符串对象是否以指定的str开头
* boolean endsWith(String str):判断字符串对象是否以指定的str结尾
*/
public class StringDemo {
  public static void main(String[] args) {
      //创建字符串对象
      String s1 = "hello";
      String s2 = "hello";
      String s3 = "Hello";
      
      //boolean equals(Object obj):比较字符串的内容是否相同
      System.out.println(s1.equals(s2));
      System.out.println(s1.equals(s3));
      System.out.println("-----------");
      
      //boolean equalsIgnoreCase(String str):比较字符串的内容是否相同,忽略大小写
      System.out.println(s1.equalsIgnoreCase(s2));
      System.out.println(s1.equalsIgnoreCase(s3));
      System.out.println("-----------");
      
      //boolean startsWith(String str):判断字符串对象是否以指定的str开头
      System.out.println(s1.startsWith("he"));
      System.out.println(s1.startsWith("ll"));
  }
}
  • 判断功能案例
    需求:模拟登录,给三次机会,并提示还有几次
  • 案例代码五:
package com.neuedu.demo;
import java.util.Scanner;
/*
* 模拟登录,给三次机会,并提示还有几次。
* 
* 分析：
*         A:定义两个字符串对象，用于存储已经存在的用户名和密码
*         B:键盘录入用户名和密码
*         C:拿键盘录入的用户名和密码和已经存在的用户名和密码进行比较
*             如果内容相同，提示登录成功
*             如果内容不同，提示登录失败，并提示还有几次机会
*/
public class StringTest {
  public static void main(String[] args) {
      //定义两个字符串对象，用于存储已经存在的用户名和密码
      String username = "admin";
      String password = "admin";
      
      //给三次机会，用for循环实现
      for(int x=0; x<3; x++) {
          //键盘录入用户名和密码
          Scanner sc = new Scanner(System.in);
          System.out.println("请输入用户名：");
          String name = sc.nextLine();
          System.out.println("请输入密码：");
          String pwd = sc.nextLine();
          
          //拿键盘录入的用户名和密码和已经存在的用户名和密码进行比较
          if(username.equals(name) && password.equals(pwd)) {
              System.out.println("登录成功");
              break;
          }else {
              if((2-x) ==0) {
                  System.out.println("用户名和密码被锁定,请与管理员联系");
              }else {
                  System.out.println("登录失败,你还有"+(2-x)+"次机会"); //2,1,0
              }
          }
      }
  }
}
  • String类的获取功能
  • 获取方法演示
package com.neuedu.demo;
/*
* String类的获取功能：
* int length():获取字符串的长度，其实也就是字符个数
* char charAt(int index):获取指定索引处的字符
* int indexOf(String str):获取str在字符串对象中第一次出现的索引
* String substring(int start):从start开始截取字符串
* String substring(int start,int end):从start开始，到end结束截取字符串。包括start，不包括end
*/
public class StringDemo {
  public static void main(String[] args) {
      //创建字符串对象
      String s = "helloworld";
      
      //int length():获取字符串的长度，其实也就是字符个数
      System.out.println(s.length());
      System.out.println("--------");
      
      //char charAt(int index):获取指定索引处的字符
      System.out.println(s.charAt(0));
      System.out.println(s.charAt(1));
      System.out.println("--------");
      
      //int indexOf(String str):获取str在字符串对象中第一次出现的索引
      System.out.println(s.indexOf("l"));
      System.out.println(s.indexOf("owo"));
      System.out.println(s.indexOf("ak"));
      System.out.println("--------");
      
      //String substring(int start):从start开始截取字符串
      System.out.println(s.substring(0));
      System.out.println(s.substring(5));
      System.out.println("--------");
      
      //String substring(int start,int end):从start开始，到end结束截取字符串
      System.out.println(s.substring(0, s.length()));
      System.out.println(s.substring(3,8));
  }
}
  • 获取功能案例
  • 案例代码六:
package com.neuedu.demo
/*
* 遍历字符串(获取字符串中的每一个字符)
*/
public class StringTest {
  public static void main(String[] args) {
      //创建一个字符串对象
      String s = "abcde";
      
      //原始做法
      System.out.println(s.charAt(0));
      System.out.println(s.charAt(1));
      System.out.println(s.charAt(2));
      System.out.println(s.charAt(3));
      System.out.println(s.charAt(4));
      System.out.println("---------");
      
      //用for循环改进
      for(int x=0; x<5; x++) {
          System.out.println(s.charAt(x));
      }
      System.out.println("---------");
      
      //用length()方法获取字符串的长度
      for(int x=0; x<s.length(); x++) {
          System.out.println(s.charAt(x));
      }
  }
}
  • 案例代码七:
package com.neuedu.demo;
import java.util.Scanner;
/*
* 统计一个字符串中大写字母字符，小写字母字符，数字字符出现的次数。(不考虑其他字符)
* 
* 分析：
*         A:键盘录入一个字符串数据
*         B:定义三个统计变量，初始化值都是0
*         C:遍历字符串，得到每一个字符
*         D:拿字符进行判断
*             假如ch是一个字符。
*             大写：ch>='A' && ch<='Z'
*             小写：ch>='a' && ch<='z'
*             数字：ch>='0' && ch<='9'
*         E:输出结果
*/
public class StringTest2 {
  public static void main(String[] args) {
      //键盘录入一个字符串数据
      Scanner sc = new Scanner(System.in);
      System.out.println("请输入一个字符串数据：");
      String s = sc.nextLine();
      
      //定义三个统计变量，初始化值都是0
      int bigCount = 0;
      int smallCount = 0;
      int numberCount = 0;
      
      //遍历字符串，得到每一个字符
      for(int x=0; x<s.length(); x++) {
          char ch = s.charAt(x);
          //拿字符进行判断
          if(ch>='A' && ch<='Z') {
              bigCount++;
          }else if(ch>='a' && ch<='z') {
              smallCount++;
          }else if(ch>='0' && ch<='9') {
              numberCount++;
          }else {
              System.out.println("该字符"+ch+"非法");
          }
      }
      
      //输出结果
      System.out.println("大写字符："+bigCount+"个");
      System.out.println("小写字符："+smallCount+"个");
      System.out.println("数字字符："+numberCount+"个");
  }
}
  • String类的转换功能
  • 转换方法演示
    char[] toCharArray():把字符串转换为字符数组
    String toLowerCase():把字符串转换为小写字符串
    String toUpperCase():把字符串转换为大写字符串
  • 案例代码八:
package com.neuedu.demo;
/*
* String类的转换功能：
* char[] toCharArray():把字符串转换为字符数组
* String toLowerCase():把字符串转换为小写字符串
* String toUpperCase():把字符串转换为大写字符串
* 
* 字符串的遍历：
*         A:length()加上charAt()
*         B:把字符串转换为字符数组，然后遍历数组
*/
public class StringDemo {
  public static void main(String[] args) {
      //创建字符串对象
      String s = "abcde";
      
      //char[] toCharArray():把字符串转换为字符数组
      char[] chs = s.toCharArray();
      for(int x=0; x<chs.length; x++) {
          System.out.println(chs[x]);
      }
      System.out.println("-----------");
      
      //String toLowerCase():把字符串转换为小写字符串
      System.out.println("HelloWorld".toLowerCase());
      //String toUpperCase():把字符串转换为大写字符串
      System.out.println("HelloWorld".toUpperCase());
  }
}
  • 转换功能案例
  • 案例代码九:
package com.neuedu.demo;
import java.util.Scanner;

/*
* 键盘录入一个字符串，把该字符串的首字母转成大写，其余为小写。(只考虑英文大小写字母字符)
* 
* 分析：
*         A:键盘录入一个字符串
*         B:截取首字母
*         C:截取除了首字母以外的字符串
*         D:B转大写+C转小写
*         E:输出即可
*/
public class StringTest {
  public static void main(String[] args) {
      //键盘录入一个字符串
      Scanner sc = new Scanner(System.in);
      System.out.println("请输入一个字符串：");
      String s = sc.nextLine();
      
      //截取首字母
      String s1 = s.substring(0, 1);
      
      //截取除了首字母以外的字符串
      String s2 = s.substring(1);
      
      //B转大写+C转小写
      String s3 = s1.toUpperCase()+s2.toLowerCase();
      
      //输出即可
      System.out.println("s3:"+s3);
  }
}
  • String类的其它功能
  • 其它方法演示
  • 案例代码十:
package com.neuedu.demo;
/*
* 去除字符串两端空格   
*     String trim()
* 按照指定符号分割字符串 
*     String[] split(String str)
*/
public class StringDemo {
  public static void main(String[] args) {
      //创建字符串对象
      String s1 = "helloworld";
      String s2 = "  helloworld  ";
      String s3 = "  hello  world  ";
      System.out.println("---"+s1+"---");
      System.out.println("---"+s1.trim()+"---");
      System.out.println("---"+s2+"---");
      System.out.println("---"+s2.trim()+"---");
      System.out.println("---"+s3+"---");
      System.out.println("---"+s3.trim()+"---");
      System.out.println("-------------------");
                                                              
      //String[] split(String str)
      //创建字符串对象
      String s4 = "aa,bb,cc";
      String[] strArray = s4.split(",");
      for(int x=0; x<strArray.length; x++) {
          System.out.println(strArray[x]);
      }
  }
}
  • String类的其它案例
  • 案例代码十一:
package com.neuedu.demo;
/*
* 把数组中的数据按照指定个格式拼接成一个字符串
* 举例：int[] arr = {1,2,3}; 
* 输出结果：[1, 2, 3]
* 
* 分析：
*         A:定义一个int类型的数组
*         B:写方法实现把数组中的元素按照指定的格式拼接成一个字符串
*         C:调用方法
*         D:输出结果
*/
public class StringTest {
  public static void main(String[] args) {
      //定义一个int类型的数组
      int[] arr = {1,2,3};
      
      //写方法实现把数组中的元素按照指定的格式拼接成一个字符串
      
      //调用方法
      String s = arrayToString(arr);
      
      //输出结果
      System.out.println("s:"+s);
  }
  
  /*
   * 两个明确：
   *      返回值类型：String
   *      参数列表：int[] arr
   */
  public static String arrayToString(int[] arr) {
      String s = "";
      
      //[1, 2, 3]
      s += "[";
      for(int x=0; x<arr.length; x++) {
          if(x==arr.length-1) {
              s += arr[x];
          }else {
              s += arr[x];
              s += ", ";
          }
      }
      s += "]";
      return s;
  }
}
  • 案例代码十二:
package com.neuedu.demo;
import java.util.Scanner;
/*
* 字符串反转
* 举例：键盘录入”abc”        
* 输出结果：”cba”
* 
* 分析：
*         A:键盘录入一个字符串
*         B:写方法实现字符串的反转
*             a:把字符串倒着遍历，得到的每一个字符拼接成字符串。
*             b:把字符串转换为字符数组，然后对字符数组进行反转，最后在把字符数组转换为字符串
*         C:调用方法
*         D:输出结果
*/
public class StringTest2 {
  public static void main(String[] args) {
      //键盘录入一个字符串
      Scanner sc = new Scanner(System.in);
      System.out.println("请输入一个字符串：");
      String s = sc.nextLine();
      
      //写方法实现字符串的反转
      
      //调用方法
      String result = reverse(s);
      
      //输出结果
      System.out.println("result:"+result);
  }
  
  
  
  /*
   * 把字符串倒着遍历，得到的每一个字符拼接成字符串。
   * 
   * 两个明确：
   *      返回值类型：String
   *      参数列表：String s
   */
  
  /*
  public static String reverse(String s) {
      String ss = "";
      
      for(int x=s.length()-1; x>=0; x--) {
          ss += s.charAt(x);
      }
      
      return ss;
  }
  */
  
  //把字符串转换为字符数组，然后对字符数组进行反转，最后在把字符数组转换为字符串
  public static String reverse(String s) {
      //把字符串转换为字符数组
      char[] chs = s.toCharArray();
      
      //对字符数组进行反转
      for(int start=0,end=chs.length-1; start<=end; start++,end--) {
          char temp = chs[start];
          chs[start] = chs[end];
          chs[end] = temp;
      }
      
      //最后在把字符数组转换为字符串
      String ss = new String(chs);
      return ss;
  }
}
三、StringBuilder类
  • StringBuilder类概述

StringBuilder:是一个可变的字符串。字符串缓冲区类。

  • String和StringBuilder的区别：
    • String的内容是固定的
    • StringBuilder的内容是可变的

  • +=拼接字符串耗费内存原因:
    每次拼接都会产生新的字符串对象,而利用StringBuilder来拼接字符串自始至终用的都是同一个StringBuilder容器


    内存.png
  • StringBuilder类的常用方法
  • A:构造方法:
    StringBuilder()
  • B:成员方法:
    public int capacity():返回当前容量 (理论值)
    public int length():返回长度(已经存储的字符个数)
    public StringBuilder append(任意类型):添加数据，并返回自身对象
    public StringBuilder reverse():反转功能
  • 案例代码十三:
package com.neuedu.demo;
/*
* StringBuilder:是一个可变的字符串。字符串缓冲区类。
* 
* String和StringBuilder的区别：
*         String的内容是固定的。
*         StringBuilder的内容是可变的。
* 
* 构造方法：
*         StringBuilder()
* 
* 成员方法：
*         public int capacity():返回当前容量
*         public int length():返回长度（字符数）
* 
*         容量：理论值
*         长度：实际值
*/
public class StringBuilderDemo {
  public static void main(String[] args) {
      //创建对象
      StringBuilder sb = new StringBuilder();
      System.out.println("sb:"+sb);
      System.out.println("sb.capacity():"+sb.capacity());
      System.out.println("sb.length():"+sb.length());
  }
}
  • 案例代码十四:
package com.neuedu.demo;
/*
* 添加功能
*     public StringBuilder append(任意类型):添加数据，并返回自身对象
* 反转功能
*     public StringBuilder reverse()
*/
public class StringBuilderDemo {
  public static void main(String[] args) {
      //创建对象
      StringBuilder sb = new StringBuilder();
      
      //public StringBuilder append(任意类型)
      //StringBuilder sb2 = sb.append("hello");
      
      /*
      System.out.println("sb:"+sb);
      System.out.println("sb2:"+sb2);
      System.out.println(sb == sb2); //true
      */
      
      /*
      sb.append("hello");
      sb.append("world");
      sb.append(true);
      sb.append(100);
      */
      
      //链式编程
      sb.append("hello").append("world").append(true).append(100);
      
      System.out.println("sb:"+sb);
      
      //public StringBuilder reverse()
      sb.reverse();
      System.out.println("sb:"+sb);
      
  }
}
  • StringBuilder案例
  • 案例一需求:
    StringBuilder和String通过方法完成相互转换
  • 案例代码十五:
package com.neuedu.demo;
/*
* StringBuilder和String的相互转换
* 
* StringBuilder -- String
*         public String toString():通过toString()就可以实现把StringBuilder转成String
* 
* String -- StringBuilder
*         StringBuilder(String str):通过构造方法就可以实现把String转成StringBuilder
*/
public class StringBuilderTest {
  public static void main(String[] args) {
      //StringBuilder -- String
      /*
      StringBuilder sb = new StringBuilder();
      sb.append("hello").append("world");
      
      String s = sb.toString();
      System.out.println(s);
      */
      
      //String -- StringBuilder
      String s = "helloworld";
      StringBuilder sb = new StringBuilder(s);
      System.out.println(sb);
  }
}
  • 案例二需求:
    利用StringBuilder把数组拼接成一个字符串
    • 举例：
      int[] arr = {1,2,3};
    • 结果：
      [1, 2, 3]
  • 案例代码十六:
package com.neuedu.demo;
/*
* 把数组拼接成一个字符串
* 举例：
*         int[] arr = {1,2,3};
* 结果：
*         [1, 2, 3]
*/
public class StringBuilderTest2 {
  public static void main(String[] args) {
      //定义一个数组
      int[] arr = {1,2,3};
      
      //写方法实现拼接
      
      //调用方法
      String s = arrayToString(arr);
      
      //输出结果
      System.out.println("s:"+s);
  }
  
  /*
   * 两个明确：
   *      返回值类型：String
   *      参数列表：int[] arr
   */
  public static String arrayToString(int[] arr) {
      StringBuilder sb = new StringBuilder();
      //[1, 2, 3]
      sb.append("[");
      for(int x=0; x<arr.length; x++) {
          if(x==arr.length-1) {
              sb.append(arr[x]);
          }else {
              sb.append(arr[x]).append(", ");
          }
      }
      sb.append("]");
      
      String result = sb.toString();
      
      return result;
  }
}
  • 案例三需求:

利用StringBuilder完成字符串反转

  • 案例代码十七:
package com.neuedu.demo;
import java.util.Scanner;
/*
* 把字符串反转
* 
* 分析：
*         A:键盘录入一个字符串
*         B:写方法实现反转
*             String -- StringBuilder -- reverse() -- String
*         C:调用方法
*         D:输出结果
*/
public class StringBuilderTest3 {
  public static void main(String[] args) {
      //键盘录入一个字符串
      Scanner sc = new Scanner(System.in);
      System.out.println("请输入一个字符串：");
      String s = sc.nextLine();
      
      //写方法实现反转
      
      //调用方法
      String result = myReverse(s);
      
      //输出结果
      System.out.println("result:"+result);
  }
  
  /*
   * 两个明确：
   *      返回值类型：String
   *      参数列表：String
   */
  public static String myReverse(String s) {
      //String -- StringBuilder -- reverse() -- String
      StringBuilder sb = new StringBuilder(s);
      sb.reverse();
      String result = sb.toString();
      return result;
  }
}
  • 案例四需求:
    判断一个字符串是否是对称字符串
    例如"abc"不是对称字符串，"aba"、"abba"、"aaa"、"mnanm"是对称字符串
  • 案例代码十八:
package com.neuedu.demo;
import java.util.Scanner;
/*
* 判断一个字符串是否是对称字符串
* 例如"abc"不是对称字符串，"aba"、"abba"、"aaa"、"mnanm"是对称字符串
*
* 分析：
*  A:键盘录入一个字符串
*  B:写方法实现判断一个字符串是否是对称字符串
* 把字符串反转，和反转前的字符串进行比较，如果内容相同，就说明是对称字符串
*  C:调用方法
*  D:输出结果
*/
public class StringBuilderTest4 {
public static void main(String[] args) {
//键盘录入一个字符串
Scanner sc = new Scanner(System.in);
System.out.println("请输入一个字符串：");
String s = sc.nextLine();
//写方法实现判断一个字符串是否是对称字符串
//调用方法
boolean b = isSymmetry(s);
//输出结果
System.out.println("b:"+b);
}
/*
* 两个明确：
* 返回值类型：boolean
* 参数列表：String s
*/
public static boolean isSymmetry(String s) {
//把字符串反转，和反转前的字符串进行比较，如果内容相同，就说明是对称字符串
StringBuilder sb = new StringBuilder(s);
sb.reverse();
String result = sb.toString();
return result.equals(s);
}
}
©著作权归作者所有,转载或内容合作请联系作者
  • 人面猴
    序言：七十年代末，一起剥皮案震惊了整个滨河市，随后出现的几起案子，更是在滨河造成了极大的恐慌，老刑警刘岩，带你破解...
    沈念sama阅读 204,732评论 6赞 478
  • 死咒
    序言：滨河连续发生了三起死亡事件，死亡现场离奇诡异，居然都是意外死亡，警方通过查阅死者的电脑和手机，发现死者居然都...
    沈念sama阅读 87,496评论 2赞 381
  • 救了他两次的神仙让他今天三更去死
    文/潘晓璐 我一进店门，熙熙楼的掌柜王于贵愁眉苦脸地迎上来，“玉大人，你说我怎么就摊上这事。” “怎么了？”我有些...
    开封第一讲书人阅读 151,264评论 0赞 338
  • 道士缉凶录：失踪的卖姜人
    文/不坏的土叔 我叫张陵，是天一观的道长。 经常有香客问我，道长，这世上最难降的妖魔是什么？ 我笑而不...
    开封第一讲书人阅读 54,807评论 1赞 277
  • 港岛之恋（遗憾婚礼）
    正文 为了忘掉前任，我火速办了婚礼，结果婚礼上，老公的妹妹穿的比我还像新娘。我一直安慰自己，他们只是感情好，可当我...
    茶点故事阅读 63,806评论 5赞 368
  • 恶毒庶女顶嫁案：这布局不是一般人想出来的
    文/花漫 我一把揭开白布。 她就那样静静地躺着，像睡着了一般。 火红的嫁衣衬着肌肤如雪。 梳的纹丝不乱的头发上，一...
    开封第一讲书人阅读 48,675评论 1赞 281
  • 城市分裂传说
    那天，我揣着相机与录音，去河边找鬼。 笑死，一个胖子当着我的面吹牛，可吹牛的内容都是我干的。 我是一名探鬼主播，决...
    沈念sama阅读 38,029评论 3赞 399
  • 双鸳鸯连环套：你想象不到人心有多黑
    文/苍兰香墨 我猛地睁开眼，长吁一口气：“原来是场噩梦啊……” “哼！你这毒妇竟也来了？” 一声冷哼从身侧响起，我...
    开封第一讲书人阅读 36,683评论 0赞 258
  • 万荣杀人案实录
    序言：老挝万荣一对情侣失踪，失踪者是张志新（化名）和其女友刘颖，没想到半个月后，有当地人在树林里发现了一具尸体，经...
    沈念sama阅读 41,704评论 1赞 299
  • 护林员之死
    正文 独居荒郊野岭守林人离奇死亡，尸身上长有42处带血的脓包…… 初始之章·张勋 以下内容为张勋视角 年9月15日...
    茶点故事阅读 35,666评论 2赞 321
  • 白月光启示录
    正文 我和宋清朗相恋三年，在试婚纱的时候发现自己被绿了。 大学时的朋友给我发了我未婚夫和他白月光在一起吃饭的照片。...
    茶点故事阅读 37,773评论 1赞 332
  • 活死人
    序言：一个原本活蹦乱跳的男人离奇死亡，死状恐怖，灵堂内的尸体忽然破棺而出，到底是诈尸还是另有隐情，我是刑警宁泽，带...
    沈念sama阅读 33,413评论 4赞 321
  • 日本核电站爆炸内幕
    正文 年R本政府宣布，位于F岛的核电站，受9级特大地震影响，放射性物质发生泄漏。R本人自食恶果不足惜，却给世界环境...
    茶点故事阅读 39,016评论 3赞 307
  • 男人毒药：我在死后第九天来索命
    文/蒙蒙 一、第九天 我趴在偏房一处隐蔽的房顶上张望。 院中可真热闹，春花似锦、人声如沸。这庄子的主人今日做“春日...
    开封第一讲书人阅读 29,978评论 0赞 19
  • 一桩弑父案，背后竟有这般阴谋
    文/苍兰香墨 我抬头看了看天上的太阳。三九已至，却和暖如春，着一层夹袄步出监牢的瞬间，已是汗流浃背。 一阵脚步声响...
    开封第一讲书人阅读 31,204评论 1赞 260
  • 情欲美人皮
    我被黑心中介骗来泰国打工， 没想到刚下飞机就差点儿被人妖公主榨干…… 1. 我叫王不留，地道东北人。 一个月前我还...
    沈念sama阅读 45,083评论 2赞 350
  • 代替公主和亲
    正文 我出身青楼，却偏偏与公主长得像，于是被迫代替她去往敌国和亲。 传闻我的和亲对象是个残疾皇子，可洞房花烛夜当晚...
    茶点故事阅读 42,503评论 2赞 343

推荐阅读更多精彩内容

  • JAVA经典算法50题
    【程序1】 题目：古典问题：有一对兔子，从出生后第3个月起每个月都生一对兔子，小兔子长到第三个月后每个月又生一对兔...
    开心的锣鼓阅读 3,305评论 0赞 9
  • 50道Java基础编程练习题
    50道经典Java编程练习题，将数学思维运用到编程中来。抱歉哈找不到文章的原贴了，有冒犯的麻烦知会声哈~ 1.指数...
    OSET我要编程阅读 6,940评论 0赞 9
  • 50道java初级编程题
    【程序1】 题目：古典问题：有一对兔子，从出生后第3个月起每个月都生一对兔子，小兔子长到第三个月后每个月又生一对兔...
    叶总韩阅读 5,125评论 0赞 41
  • Java知识——基础知识
    本文是我自己在秋招复习时的读书笔记，整理的知识点，也是为了防止忘记，尊重劳动成果，转载注明出处哦！如果你也喜欢，那...
    波波波先森阅读 826评论 1赞 6
  • 0722晨读感悟|穿过一二三，用好奇找寻新世界
    因为好奇，我们才会去探索；因为探索，我们更加好奇。好奇心带我们看更美的风景。 一、一台发动机 【认知需求】 好奇的...
    静心观情阅读 194评论 2赞 2