Springboot+Vue实现仿百度搜索自动提示框匹配查询功能

案例功能效果图

前端初始页面

输入搜索信息页面

点击查询结果页面

环境介绍

前端：vue

后端：springboot

jdk:1.8及以上

数据库：mysql

核心代码介绍

TypeCtrler .java

package com.yxyz.ctrler;
import java.util.ArrayList;
import java.util.List;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.util.StringUtils;
import org.springframework.web.bind.annotation.CrossOrigin;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import com.yxyz.rest.CodeMsg;
import com.yxyz.rest.Result;
import com.yxyz.service.TypeService;
import com.yxyz.vo.Type;

import io.swagger.annotations.Api;
import io.swagger.annotations.ApiImplicitParam;
import io.swagger.annotations.ApiImplicitParams;
import io.swagger.annotations.ApiOperation;

/**
* Copyright @ 2020 Zonlyn. All rights reserved.

* @Description: 该类的功能描述
*
* @version: v1.0.0
* @author: ducl
* @date: 2020年8月11日 下午5:29:00
*
* Modification History:
* Date         Author          Version            Description
*---------------------------------------------------------*
* 2020年8月11日     ducl          v1.0.0               修改原因
*/
@RestController
@RequestMapping("/type")
@CrossOrigin
@Api(value="全量数据",tags={"全量数据"})
public class TypeCtrler
{
  @Autowired
  private TypeService typeService;
  @PostMapping("/findAll")
  @ApiOperation(value="获取全量数据")
  public Object findAll()
  {
    try
    {
      List<Type> findAll = typeService.findAll();
      return Result.success(findAll);
    }
    catch(Exception e)
    {
      return Result.error(CodeMsg.SERVER_ERROR);
    }
  }
  @ApiOperation(value="批量删除")
  @ApiImplicitParams({
    @ApiImplicitParam(name = "ids", value = "需要删除的数据编号(以[id1$id2$id3$]格式传输)",dataTypeClass = String.class,required = true)
  })
  @PostMapping("/delete")
  public Object delete(String ids)
  {
    if(StringUtils.isEmpty(ids))
    {
      return Result.error(CodeMsg.NORECORDCHOOSE);
    }

    try
    {
      String[] split = ids.split("\\$");
      List<Integer> list = new ArrayList<>();
      for(String id : split)
      {
        list.add(Integer.parseInt(id));
      }
      typeService.delete(list);
      return Result.success(null);
    }
    catch (NumberFormatException e)
    {
      return Result.error(CodeMsg.PARAMERROR);
    }
    catch(Exception e)
    {
      return Result.error(CodeMsg.SERVER_ERROR);
    }
  }
  @ApiOperation(value="模糊查询关键字")
  @ApiImplicitParams({
    @ApiImplicitParam(name = "name", value = "模糊查询的关键字",dataTypeClass = String.class,required = true)
  })
  @PostMapping("/findlikename")
  public Object findLikeName(String name)
  {
    if(StringUtils.isEmpty(name))
    {
      return Result.error(CodeMsg.NORECORDCHOOSE);
    }

    try
    {
      List<Type> findLikeName = typeService.findLikeName(name);

      return Result.success(findLikeName);
    }
    catch(Exception e)
    {
      return Result.error(CodeMsg.SERVER_ERROR);
    }
  }
}

TypeService .java

package com.yxyz.service;
import java.util.List;
import com.yxyz.vo.Type;
public interface TypeService
{
  /**
   * 直接查询所有的数据
   * @return
   */
  List<Type> findAll();
  /**
   * 批量删除
   * @param ids
   */
  void delete(List<Integer> ids);
  /**
   * 根据名称模糊查询
   * @param name
   * @return
   */
  List<Type> findLikeName(String name);
}

main.js

import Vue from 'vue'

import 'normalize.css/normalize.css' // A modern alternative to CSS resets

import ElementUI from 'element-ui'
import 'element-ui/lib/theme-chalk/index.css'
// import locale from 'element-ui/lib/locale/lang/en' // lang i18n

import '@/styles/index.scss' // global css

import App from './App'
import store from './store'
import router from './router'

import '@/icons' // icon
import '@/permission' // permission control

/**
 * If you don't want to use mock-server
 * you want to use MockJs for mock api
 * you can execute: mockXHR()
 *
 * Currently MockJs will be used in the production environment,
 * please remove it before going online ! ! !
 */
if (process.env.NODE_ENV === 'production') {
  const { mockXHR } = require('../mock')
  mockXHR()
}

// set ElementUI lang to EN
Vue.use(ElementUI)
// 如果想要中文版 element-ui，按如下方式声明
// Vue.use(ElementUI)

Vue.config.productionTip = false

new Vue({
  el: '#app',
  router,
  store,
  render: h => h(App)
})

index.vue

<template>
  <div class="search">
    <el-col :span="12">
      <span>搜索：</span>
      <el-autocomplete
        v-model="title"
        class="inline-input"
        :fetch-suggestions="querySearch"
        placeholder="请输入内容"
        :trigger-on-focus="false"
        @select="handleSelect"
      />
    </el-col>
    <el-col :span="18" style="margin-top:20px;">
      <div style="margin-bottom:10px;">结果</div>
      <el-table
        :data="tableData"
        size="mini"
        border
        style="width: 100%"
      >
        <el-table-column
          prop="id"
          label="id"
          width="100"
        />
        <el-table-column
          prop="name"
          label="名称"
          width="120"
        />
        <el-table-column
          prop="category"
          label="分类"
          width="120"
        />
        <el-table-column
          prop="content"
          label="内容"
        />

      </el-table>
    </el-col>

  </div>
</template>

<script>
import axios from 'axios'
export default {
  components: {},
  props: {},
  data() {
    return {
      title: '',
      selectItem: {},
      tableData: []
    }
  },
  computed: {},
  watch: {},
  created() {},
  mounted() {

  },
  methods: {
    async querySearch(queryString, cb) {
      const data = await this.getData(queryString)
      const result = data.map(item => {
        return {
          ...item,
          value: item && item.name
        }
      })
      // 调用 callback 返回建议列表的数据
      cb(result)
    },
    async getData(queryString) {
      const formData = new FormData()
      formData.append('name', queryString)
      const res = await axios({
        method: 'post',
        url: 'http://139.159.147.237:8080/yxyz/type/findlikename',
        data: formData,
        headers: {
          'Content-Type': 'application/x-www-form-urlencoded'
        }
      })
      console.log(res, 'res')
      return res.data.data
    },
    handleSelect(item) {
      console.log(item)
      this.selectItem = item
      this.tableData = [item]
    }

  }
}
</script>

<style scoped lang="scss">
.search{
    display:flex;
    flex-direction: column;
    justify-content: center;
    align-items:center;
}
</style>

t_type.sql

SET FOREIGN_KEY_CHECKS=0;
DROP TABLE IF EXISTS `t_type`;
CREATE TABLE `t_type` (
  `id` int(11) NOT NULL AUTO_INCREMENT,
  `name` varchar(255) NOT NULL,
  `category` varchar(16) NOT NULL,
  `content` text,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=91 DEFAULT CHARSET=utf8;
-- ----------------------------
-- Records of t_type
-- ----------------------------
INSERT INTO `t_type` VALUES ('60', '数学12', '1004', 'Java是一门面向对象编程语言，不仅吸收了C++语言的各种优点，还摒弃了C++里难以理解的多继承、指针等概念，因此Java语言具有功能强大和简单易用两个特征。Java语言作为静态面向对象编程语言的代表，极好地实现了面向对象理论，允许程序员以优雅的思维方式进行复杂的编程 [1]  。\r\nJava具有简单性、面向对象、分布式、健壮性、安全性、平台独立与可移植性、多线程、动态性等特点 [2]  。Java可以编写桌面应用程序、Web应用程序、分布式系统和嵌入式系统应用程序等。');
INSERT INTO `t_type` VALUES ('81', 'java是什么', '1005', 'Java是一门面向对象编程语言，不仅吸收了C++语言的各种优点，还摒弃了C++里难以理解的多继承、指针等概念，因此Java语言具有功能强大和简单易用两个特征。Java语言作为静态面向对象编程语言的代表，极好地实现了面向对象理论，允许程序员以优雅的思维方式进行复杂的编程 [1]  。\r\nJava具有简单性、面向对象、分布式、健壮性、安全性、平台独立与可移植性、多线程、动态性等特点 [2]  。Java可以编写桌面应用程序、Web应用程序、分布式系统和嵌入式系统应用程序等。');
INSERT INTO `t_type` VALUES ('82', 'javascript', '1005', '作者：程序员客栈\n链接：https://www.zhihu.com/question/19813265/answer/815563899\n来源：知乎\n著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。\n\nJavaScript 最初的目的是为了“赋予网页生命”。这种编程语言我们称之为脚本。它们可以写在 HTML 中，在页面加载的时候会自动执行。脚本作为纯文本存在和执行。它们不需要特殊的准备或编译即可运行。这方面，JavaScript 和 Java 有很大的区别。为什么叫 JavaScript？JavaScript 在刚诞生的时候，它的名字叫 “LiveScript”。但是因为当时 Java 很流行，所以决定将一种新语言定位为 Java 的“弟弟”会有助于它的流行。随着 JavaScript 的发展，它已经变成了一门独立的语言，同时也有了自己的语言规范 ECMAScript。现在，它和 Java 之间没有任何关系。现在，JavaScript 不仅仅是在浏览器内执行，也可以在服务端执行，甚至还能在任意搭载了 JavaScript 引擎 的设备中都可以执行。浏览器中嵌入了 JavaScript 引擎，有时也称作 JavaScript 虚拟机。不同的引擎有不同的“代号”，例如：V8 —— Chrome 和 Opera 中的 JavaScript 引擎。SpiderMonkey —— Firefox 中的 JavaScript 引擎。……还有其他一些代号，像“Trident”，“Chakra”用于不同版本的 IE，“ChakraCore”用于 Microsoft Edge，“Nitro”和“SquirrelFish”用于 Safari，等等。上面这些名称很容易记忆，因为经常出现在网上开发者的文章中。我们也会用到这些名称。例如：某个新的功能，如果“JavaScript 引擎 V8 是支持的”，那么我们可以认为这个功能大概能在 Chrome 和 Opera 中正常运行。引擎是如何工作的？引擎很复杂，但是基本原理很简单。引擎（通常嵌入在浏览器中）读取（“解析”）脚本。然后将脚本转化（“编译”）为机器语言。然后这机器语言代码快速地运行。引擎会对流程中的每个阶段都进行优化。它甚至可以在运行时监视编译的脚本，分析数据流并根据这些对机器代码应用优化。最后，脚本会执行地非常快。');
INSERT INTO `t_type` VALUES ('83', 'java面试题', '1005', '1、面向对象的特征有哪些方面？\r\n答：面向对象的特征主要有以下几个方面：\r\n- 抽象：抽象是将一类对象的共同特征总结出来构造类的过程，包括数据抽象和行为抽象两方面。抽象只关注对象有哪些属性和行为，并不关注这些行为的细节是什么。\r\n- 继承：继承是从已有类得到继承信息创建新类的过程。提供继承信息的类被称为父类（超类、基类）；得到继承信息的类被称为子类（派生类）。继承让变化中的软件系统有了一定的延续性，同时继承也是封装程序中可变因素的重要手段（如果不能理解请阅读阎宏博士的《Java与模式》或《设计模式精解》中关于桥梁模式的部分）。\r\n- 封装：通常认为封装是把数据和操作数据的方法绑定起来，对数据的访问只能通过已定义的接口。面向对象的本质就是将现实世界描绘成一系列完全自治、封闭的对象。我们在类中编写的方法就是对实现细节的一种封装；我们编写一个类就是对数据和数据操作的封装。可以说，封装就是隐藏一切可隐藏的东西，只向外界提供最简单的编程接口（可以想想普通洗衣机和全自动洗衣机的差别，明显全自动洗衣机封装更好因此操作起来更简单；我们现在使用的智能手机也是封装得足够好的，因为几个按键就搞定了所有的事情）。\r\n- 多态性：多态性是指允许不同子类型的对象对同一消息作出不同的响应。简单的说就是用同样的对象引用调用同样的方法但是做了不同的事情。多态性分为编译时的多态性和运行时的多态性。如果将对象的方法视为对象向外界提供的服务，那么运行时的多态性可以解释为：当A系统访问B系统提供的服务时，B系统有多种提供服务的方式，但一切对A系统来说都是透明的（就像电动剃须刀是A系统，它的供电系统是B系统，B系统可以使用电池供电或者用交流电，甚至还有可能是太阳能，A系统只会通过B类对象调用供电的方法，但并不知道供电系统的底层实现是什么，究竟通过何种方式获得了动力）。方法重载（overload）实现的是编译时的多态性（也称为前绑定），而方法重写（override）实现的是运行时的多态性（也称为后绑定）。运行时的多态是面向对象最精髓的东西，要实现多态需要做两件事：1). 方法重写（子类继承父类并重写父类中已有的或抽象的方法）；2). 对象造型（用父类型引用引用子类型对象，这样同样的引用调用同样的方法就会根据子类对象的不同而表现出不同的行为）。\r\n\r\n2、访问修饰符public,private,protected,以及不写（默认）时的区别？\r\n答：\r\n\r\n修饰符  当前类  同 包  子 类  其他包\r\npublic  √  √  √  √\r\nprotected  √  √  √  ×\r\ndefault  √  √  ×  ×\r\nprivate  √  ×  ×  ×\r\n类的成员不写访问修饰时默认为default。默认对于同一个包中的其他类相当于公开（public），对于不是同一个包中的其他类相当于私有（private）。受保护（protected）对子类相当于公开，对不是同一包中的没有父子关系的类相当于私有。Java中，外部类的修饰符只能是public或默认，类的成员（包括内部类）的修饰符可以是以上四种。\r\n\r\n3、String 是最基本的数据类型吗？\r\n答：不是。Java中的基本数据类型只有8个：byte、short、int、long、float、double、char、boolean；除了基本类型（primitive type），剩下的都是引用类型（reference type），Java 5以后引入的枚举类型也算是一种比较特殊的引用类型。\r\n\r\n4、float f=3.4;是否正确？\r\n答:不正确。3.4是双精度数，将双精度型（double）赋值给浮点型（float）属于下转型（down-casting，也称为窄化）会造成精度损失，因此需要强制类型转换float f =(float)3.4; 或者写成float f =3.4F;。\r\n\r\n5、short s1 = 1; s1 = s1 + 1;有错吗?short s1 = 1; s1 += 1;有错吗？\r\n答：对于short s1 = 1; s1 = s1 + 1;由于1是int类型，因此s1+1运算结果也是int 型，需要强制转换类型才能赋值给short型。而short s1 = 1; s1 += 1;可以正确编译，因为s1+= 1;相当于s1 = (short)(s1 + 1);其中有隐含的强制类型转换。\r\n\r\n6、Java有没有goto？\r\n答：goto 是Java中的保留字，在目前版本的Java中没有使用。（根据James Gosling（Java之父）编写的《The Java Programming Language》一书的附录中给出了一个Java关键字列表，其中有goto和const，但是这两个是目前无法使用的关键字，因此有些地方将其称之为保留字，其实保留字这个词应该有更广泛的意义，因为熟悉C语言的程序员都知道，在系统类库中使用过的有特殊意义的单词或单词的组合都被视为保留字）\r\n\r\n7、int和Integer有什么区别？\r\n答：Java是一个近乎纯洁的面向对象编程语言，但是为了编程的方便还是引入了基本数据类型，但是为了能够将这些基本数据类型当成对象操作，Java为每一个基本数据类型都引入了对应的包装类型（wrapper class），int的包装类就是Integer，从Java 5开始引入了自动装箱/拆箱机制，使得二者可以相互转换。\r\nJava 为每个原始类型提供了包装类型：\r\n- 原始类型: boolean，char，byte，short，int，long，float，double \r\n- 包装类型：Boolean，Character，Byte，Short，Integer，Long，Float，Double\r\n\r\nclass AutoUnboxingTest {\r\n\r\n    public static void main(String[] args) {\r\n        Integer a = new Integer(3);\r\n        Integer b = 3;                  // 将3自动装箱成Integer类型\r\n        int c = 3;\r\n        System.out.println(a == b);     // false 两个引用没有引用同一对象\r\n        System.out.println(a == c);     // true a自动拆箱成int类型再和c比较\r\n    }\r\n}\r\n1\r\n2\r\n3\r\n4\r\n5\r\n6\r\n7\r\n8\r\n9\r\n10\r\n最近还遇到一个面试题，也是和自动装箱和拆箱有点关系的，代码如下所示：\r\n\r\npublic class Test03 {\r\n\r\n    public static void main(String[] args) {\r\n        Integer f1 = 100, f2 = 100, f3 = 150, f4 = 150;\r\n\r\n        System.out.println(f1 == f2);\r\n        System.out.println(f3 == f4);\r\n    }\r\n}\r\n1\r\n2\r\n3\r\n4\r\n5\r\n6\r\n7\r\n8\r\n9\r\n如果不明就里很容易认为两个输出要么都是true要么都是false。首先需要注意的是f1、f2、f3、f4四个变量都是Integer对象引用，所以下面的==运算比较的不是值而是引用。装箱的本质是什么呢？当我们给一个Integer对象赋一个int值的时候，会调用Integer类的静态方法valueOf，如果看看valueOf的源代码就知道发生了什么。\r\n\r\n    public static Integer valueOf(int i) {\r\n        if (i >= IntegerCache.low && i <= IntegerCache.high)\r\n            return IntegerCache.cache[i + (-IntegerCache.low)];\r\n        return new Integer(i);\r\n    }\r\n1\r\n2\r\n3\r\n4\r\n5\r\nIntegerCache是Integer的内部类，其代码如下所示：\r\n\r\n/**\r\n     * Cache to support the object identity semantics of autoboxing for values between\r\n     * -128 and 127 (inclusive) as required by JLS.\r\n     *\r\n     * The cache is initialized on first usage.  The size of the cache\r\n     * may be controlled by the {@code -XX:AutoBoxCacheMax=<size>} option.\r\n     * During VM initialization, java.lang.Integer.IntegerCache.high property\r\n     * may be set and saved in the private system properties in the\r\n     * sun.misc.VM class.\r\n     */\r\n\r\n    private static class IntegerCache {\r\n        static final int low = -128;\r\n        static final int high;\r\n        static final Integer cache[];\r\n\r\n        static {\r\n            // high value may be configured by property\r\n            int h = 127;\r\n            String integerCacheHighPropValue =\r\n                sun.misc.VM.getSavedProperty(\"java.lang.Integer.IntegerCache.high\");\r\n            if (integerCacheHighPropValue != null) {\r\n                try {\r\n                    int i = parseInt(integerCacheHighPropValue);\r\n                    i = Math.max(i, 127);\r\n                    // Maximum array size is Integer.MAX_VALUE\r\n                    h = Math.min(i, Integer.MAX_VALUE - (-low) -1);\r\n                } catch( NumberFormatException nfe) {\r\n                    // If the property cannot be parsed into an int, ignore it.\r\n                }\r\n            }\r\n            high = h;\r\n\r\n            cache = new Integer[(high - low) + 1];\r\n            int j = low;\r\n            for(int k = 0; k < cache.length; k++)\r\n                cache[k] = new Integer(j++);\r\n\r\n            // range [-128, 127] must be interned (JLS7 5.1.7)\r\n            assert IntegerCache.high >= 127;\r\n        }\r\n\r\n        private IntegerCache() {}\r\n    }\r\n1\r\n2\r\n3\r\n4\r\n5\r\n6\r\n7\r\n8\r\n9\r\n10\r\n11\r\n12\r\n13\r\n14\r\n15\r\n16\r\n17\r\n18\r\n19\r\n20\r\n21\r\n22\r\n23\r\n24\r\n25\r\n26\r\n27\r\n28\r\n29\r\n30\r\n31\r\n32\r\n33\r\n34\r\n35\r\n36\r\n37\r\n38\r\n39\r\n40\r\n41\r\n42\r\n43\r\n44\r\n简单的说，如果整型字面量的值在-128到127之间，那么不会new新的Integer对象，而是直接引用常量池中的Integer对象，所以上面的面试题中f1==f2的结果是true，而f3==f4的结果是false。');
INSERT INTO `t_type` VALUES ('84', 'java培训', '1005', '像尚学堂之类培训机构，说是4个月培训后就业，还是就业后用工资还学费，每月922，一共12900.“JAVA+Android+云计算+海量数据处理”高薪就业课程 这是他们的培训课程，一共7个阶段，我觉得4个月学会编程根本不现实啊，有大神看看可靠吗？');
INSERT INTO `t_type` VALUES ('85', 'java基础知识', '1005', '1、面向对象的特征有哪些方面？\r\n答：面向对象的特征主要有以下几个方面：\r\n- 抽象：抽象是将一类对象的共同特征总结出来构造类的过程，包括数据抽象和行为抽象两方面。抽象只关注对象有哪些属性和行为，并不关注这些行为的细节是什么。\r\n- 继承：继承是从已有类得到继承信息创建新类的过程。提供继承信息的类被称为父类（超类、基类）；得到继承信息的类被称为子类（派生类）。继承让变化中的软件系统有了一定的延续性，同时继承也是封装程序中可变因素的重要手段（如果不能理解请阅读阎宏博士的《Java与模式》或《设计模式精解》中关于桥梁模式的部分）。\r\n- 封装：通常认为封装是把数据和操作数据的方法绑定起来，对数据的访问只能通过已定义的接口。面向对象的本质就是将现实世界描绘成一系列完全自治、封闭的对象。我们在类中编写的方法就是对实现细节的一种封装；我们编写一个类就是对数据和数据操作的封装。可以说，封装就是隐藏一切可隐藏的东西，只向外界提供最简单的编程接口（可以想想普通洗衣机和全自动洗衣机的差别，明显全自动洗衣机封装更好因此操作起来更简单；我们现在使用的智能手机也是封装得足够好的，因为几个按键就搞定了所有的事情）。\r\n- 多态性：多态性是指允许不同子类型的对象对同一消息作出不同的响应。简单的说就是用同样的对象引用调用同样的方法但是做了不同的事情。多态性分为编译时的多态性和运行时的多态性。如果将对象的方法视为对象向外界提供的服务，那么运行时的多态性可以解释为：当A系统访问B系统提供的服务时，B系统有多种提供服务的方式，但一切对A系统来说都是透明的（就像电动剃须刀是A系统，它的供电系统是B系统，B系统可以使用电池供电或者用交流电，甚至还有可能是太阳能，A系统只会通过B类对象调用供电的方法，但并不知道供电系统的底层实现是什么，究竟通过何种方式获得了动力）。方法重载（overload）实现的是编译时的多态性（也称为前绑定），而方法重写（override）实现的是运行时的多态性（也称为后绑定）。运行时的多态是面向对象最精髓的东西，要实现多态需要做两件事：1). 方法重写（子类继承父类并重写父类中已有的或抽象的方法）；2). 对象造型（用父类型引用引用子类型对象，这样同样的引用调用同样的方法就会根据子类对象的不同而表现出不同的行为）。\r\n\r\n2、访问修饰符public,private,protected,以及不写（默认）时的区别？\r\n答：\r\n\r\n修饰符  当前类  同 包  子 类  其他包\r\npublic  √  √  √  √\r\nprotected  √  √  √  ×\r\ndefault  √  √  ×  ×\r\nprivate  √  ×  ×  ×\r\n类的成员不写访问修饰时默认为default。默认对于同一个包中的其他类相当于公开（public），对于不是同一个包中的其他类相当于私有（private）。受保护（protected）对子类相当于公开，对不是同一包中的没有父子关系的类相当于私有。Java中，外部类的修饰符只能是public或默认，类的成员（包括内部类）的修饰符可以是以上四种。\r\n\r\n3、String 是最基本的数据类型吗？\r\n答：不是。Java中的基本数据类型只有8个：byte、short、int、long、float、double、char、boolean；除了基本类型（primitive type），剩下的都是引用类型（reference type），Java 5以后引入的枚举类型也算是一种比较特殊的引用类型。\r\n\r\n4、float f=3.4;是否正确？\r\n答:不正确。3.4是双精度数，将双精度型（double）赋值给浮点型（float）属于下转型（down-casting，也称为窄化）会造成精度损失，因此需要强制类型转换float f =(float)3.4; 或者写成float f =3.4F;。\r\n\r\n5、short s1 = 1; s1 = s1 + 1;有错吗?short s1 = 1; s1 += 1;有错吗？\r\n答：对于short s1 = 1; s1 = s1 + 1;由于1是int类型，因此s1+1运算结果也是int 型，需要强制转换类型才能赋值给short型。而short s1 = 1; s1 += 1;可以正确编译，因为s1+= 1;相当于s1 = (short)(s1 + 1);其中有隐含的强制类型转换。\r\n\r\n6、Java有没有goto？\r\n答：goto 是Java中的保留字，在目前版本的Java中没有使用。（根据James Gosling（Java之父）编写的《The Java Programming Language》一书的附录中给出了一个Java关键字列表，其中有goto和const，但是这两个是目前无法使用的关键字，因此有些地方将其称之为保留字，其实保留字这个词应该有更广泛的意义，因为熟悉C语言的程序员都知道，在系统类库中使用过的有特殊意义的单词或单词的组合都被视为保留字）\r\n\r\n7、int和Integer有什么区别？\r\n答：Java是一个近乎纯洁的面向对象编程语言，但是为了编程的方便还是引入了基本数据类型，但是为了能够将这些基本数据类型当成对象操作，Java为每一个基本数据类型都引入了对应的包装类型（wrapper class），int的包装类就是Integer，从Java 5开始引入了自动装箱/拆箱机制，使得二者可以相互转换。\r\nJava 为每个原始类型提供了包装类型：\r\n- 原始类型: boolean，char，byte，short，int，long，float，double \r\n- 包装类型：Boolean，Character，Byte，Short，Integer，Long，Float，Double\r\n\r\nclass AutoUnboxingTest {\r\n\r\n    public static void main(String[] args) {\r\n        Integer a = new Integer(3);\r\n        Integer b = 3;                  // 将3自动装箱成Integer类型\r\n        int c = 3;\r\n        System.out.println(a == b);     // false 两个引用没有引用同一对象\r\n        System.out.println(a == c);     // true a自动拆箱成int类型再和c比较\r\n    }\r\n}\r\n1\r\n2\r\n3\r\n4\r\n5\r\n6\r\n7\r\n8\r\n9\r\n10\r\n最近还遇到一个面试题，也是和自动装箱和拆箱有点关系的，代码如下所示：\r\n\r\npublic class Test03 {\r\n\r\n    public static void main(String[] args) {\r\n        Integer f1 = 100, f2 = 100, f3 = 150, f4 = 150;\r\n\r\n        System.out.println(f1 == f2);\r\n        System.out.println(f3 == f4);\r\n    }\r\n}\r\n1\r\n2\r\n3\r\n4\r\n5\r\n6\r\n7\r\n8\r\n9\r\n如果不明就里很容易认为两个输出要么都是true要么都是false。首先需要注意的是f1、f2、f3、f4四个变量都是Integer对象引用，所以下面的==运算比较的不是值而是引用。装箱的本质是什么呢？当我们给一个Integer对象赋一个int值的时候，会调用Integer类的静态方法valueOf，如果看看valueOf的源代码就知道发生了什么。\r\n\r\n    public static Integer valueOf(int i) {\r\n        if (i >= IntegerCache.low && i <= IntegerCache.high)\r\n            return IntegerCache.cache[i + (-IntegerCache.low)];\r\n        return new Integer(i);\r\n    }\r\n1\r\n2\r\n3\r\n4\r\n5\r\nIntegerCache是Integer的内部类，其代码如下所示：\r\n\r\n/**\r\n     * Cache to support the object identity semantics of autoboxing for values between\r\n     * -128 and 127 (inclusive) as required by JLS.\r\n     *\r\n     * The cache is initialized on first usage.  The size of the cache\r\n     * may be controlled by the {@code -XX:AutoBoxCacheMax=<size>} option.\r\n     * During VM initialization, java.lang.Integer.IntegerCache.high property\r\n     * may be set and saved in the private system properties in the\r\n     * sun.misc.VM class.\r\n     */\r\n\r\n    private static class IntegerCache {\r\n        static final int low = -128;\r\n        static final int high;\r\n        static final Integer cache[];\r\n\r\n        static {\r\n            // high value may be configured by property\r\n            int h = 127;\r\n            String integerCacheHighPropValue =\r\n                sun.misc.VM.getSavedProperty(\"java.lang.Integer.IntegerCache.high\");\r\n            if (integerCacheHighPropValue != null) {\r\n                try {\r\n                    int i = parseInt(integerCacheHighPropValue);\r\n                    i = Math.max(i, 127);\r\n                    // Maximum array size is Integer.MAX_VALUE\r\n                    h = Math.min(i, Integer.MAX_VALUE - (-low) -1);\r\n                } catch( NumberFormatException nfe) {\r\n                    // If the property cannot be parsed into an int, ignore it.\r\n                }\r\n            }\r\n            high = h;\r\n\r\n            cache = new Integer[(high - low) + 1];\r\n            int j = low;\r\n            for(int k = 0; k < cache.length; k++)\r\n                cache[k] = new Integer(j++);\r\n\r\n            // range [-128, 127] must be interned (JLS7 5.1.7)\r\n            assert IntegerCache.high >= 127;\r\n        }\r\n\r\n        private IntegerCache() {}\r\n    }\r\n1\r\n2\r\n3\r\n4\r\n5\r\n6\r\n7\r\n8\r\n9\r\n10\r\n11\r\n12\r\n13\r\n14\r\n15\r\n16\r\n17\r\n18\r\n19\r\n20\r\n21\r\n22\r\n23\r\n24\r\n25\r\n26\r\n27\r\n28\r\n29\r\n30\r\n31\r\n32\r\n33\r\n34\r\n35\r\n36\r\n37\r\n38\r\n39\r\n40\r\n41\r\n42\r\n43\r\n44\r\n简单的说，如果整型字面量的值在-128到127之间，那么不会new新的Integer对象，而是直接引用常量池中的Integer对象，所以上面的面试题中f1==f2的结果是true，而f3==f4的结果是false。');
INSERT INTO `t_type` VALUES ('86', 'javascript:void(0)', '1005', '作者：程序员客栈\n链接：https://www.zhihu.com/question/19813265/answer/815563899\n来源：知乎\n著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。\n\nJavaScript 最初的目的是为了“赋予网页生命”。这种编程语言我们称之为脚本。它们可以写在 HTML 中，在页面加载的时候会自动执行。脚本作为纯文本存在和执行。它们不需要特殊的准备或编译即可运行。这方面，JavaScript 和 Java 有很大的区别。为什么叫 JavaScript？JavaScript 在刚诞生的时候，它的名字叫 “LiveScript”。但是因为当时 Java 很流行，所以决定将一种新语言定位为 Java 的“弟弟”会有助于它的流行。随着 JavaScript 的发展，它已经变成了一门独立的语言，同时也有了自己的语言规范 ECMAScript。现在，它和 Java 之间没有任何关系。现在，JavaScript 不仅仅是在浏览器内执行，也可以在服务端执行，甚至还能在任意搭载了 JavaScript 引擎 的设备中都可以执行。浏览器中嵌入了 JavaScript 引擎，有时也称作 JavaScript 虚拟机。不同的引擎有不同的“代号”，例如：V8 —— Chrome 和 Opera 中的 JavaScript 引擎。SpiderMonkey —— Firefox 中的 JavaScript 引擎。……还有其他一些代号，像“Trident”，“Chakra”用于不同版本的 IE，“ChakraCore”用于 Microsoft Edge，“Nitro”和“SquirrelFish”用于 Safari，等等。上面这些名称很容易记忆，因为经常出现在网上开发者的文章中。我们也会用到这些名称。例如：某个新的功能，如果“JavaScript 引擎 V8 是支持的”，那么我们可以认为这个功能大概能在 Chrome 和 Opera 中正常运行。引擎是如何工作的？引擎很复杂，但是基本原理很简单。引擎（通常嵌入在浏览器中）读取（“解析”）脚本。然后将脚本转化（“编译”）为机器语言。然后这机器语言代码快速地运行。引擎会对流程中的每个阶段都进行优化。它甚至可以在运行时监视编译的脚本，分析数据流并根据这些对机器代码应用优化。最后，脚本会执行地非常快。');
INSERT INTO `t_type` VALUES ('87', 'java老版手机游戏集合', '1005', '像尚学堂之类培训机构，说是4个月培训后就业，还是就业后用工资还学费，每月922，一共12900.“JAVA+Android+云计算+海量数据处理”高薪就业课程 这是他们的培训课程，一共7个阶段，我觉得4个月学会编程根本不现实啊，有大神看看可靠吗？');

项目下载地址

Springboot+Vue实现仿百度搜索自动提示框匹配查询功能链接：https://pan.baidu.com/s/13GBVbSIf6QqSaKn-yRpeEw 提取码：456w

`````````````````````````````````````````````````--完--````````````````````````````````````````````````