springboot集成redis

2021-01-13 16:44发布

站内问答 / Java
6149 19 19

springBoot如何集成redis配置

springBoot如何集成redis配置

发送
19条回答
不吃鱼的猫
2楼 · 2021-01-13 19:23

1.首先,对于配置文件,网上很多,您可以直接拿来即可使用。当然,您也可以自己写一个配...

2.接下来,需要配置redis的端口,这个端口是您安装redis时候可以设置的,如果您的r...

3.接下来,还有几个主要的参数,这要这些参数全部配置完后,基本的配置就结束了。

4.接下来,我们要去读这些配置文件。

5.接下来,我们在文件中创建了读取配置文件。


我想吃肉
3楼 · 2021-01-13 20:47

首先，需要导入的依赖，大家自己看着加

         
            org.springframework.boot
            spring-boot-starter-data-redis
        
        
            org.springframework.boot
            spring-boot-starter-web
        
        
            com.alibaba
            fastjson
            1.2.38
        
        
            org.springframework.boot
            spring-boot-starter-test
            test
        

依赖导入后需要配置下application.properties文件，个人觉得yml文件很乱，看不习惯，使用采用properties文件

#Redis
#spring.redis.host=127.0.0.1
redis.host=127.0.0.1
## Redis服务器连接端口
redis.port=6379
## 连接超时时间（毫秒）
redis.timeout=3
## Redis服务器连接密码（默认为空）
redis.password=135246
## 连接池中的最大连接数
redis.poolMaxTotal=10
## 连接池中的最大空闲连接
redis.poolMaxIdle=10
## 连接池最大阻塞等待时间（使用负值表示没有限制）
redis.poolMaxWait=3

这里需要设计下redis的密码，打开客户端

redis 127.0.0.1:6379> config set requirepass “你的密码”

验证密码

redis 127.0.0.1:6379> auth “你的密码”

这一步很重要，不设密码在后面的程序会抛个没有密码的异常，导致失败

然后 就可以直接实现RedisTemple这个类来操作Redis了，但是这里我们使用的是SringRedisTemple来操作Redis，大家可以认为这个是RedisTemple的实现类，表示都是类型；

     @Autowired
    StringRedisTemplate stringRedisTemplate;
    @Test
    public void test()  {

        // 保存字符串
        stringRedisTemplate.opsForValue().set("aaa", "111");
        
    }

打开redis的客户端，查看aaa这个key，可以确认看到111这个value。表示我们存入的key已经成功了。


image.png

接下来，redis有一个问题，就是在存对象的时候，会序列化成2进制文件。但是我们需要的是存的json格式的文件，这样方便我们测试，调试。而一般解决这个问题的方法，是需要在配置类中对这个类进行一些相关的配置，但是这样对每个类都要配置比较麻烦。
这里我们采用别的方法，存的时候采用阿里巴巴的json对对象转化成json的String类型，然后存进去，取得时候需要传入转换成的类类型。具体方法看下面

RedusTempleService.java

@Servicepublic class RedisTemplateService {

    @Autowired
    StringRedisTemplate stringRedisTemplate;

    public  boolean set(String key ,T value){

        try {

            //任意类型转换成String
            String val = beanToString(value);

            if(val==null||val.length()<=0){
                return false;
            }

            stringRedisTemplate.opsForValue().set(key,val);
            return true;
        }catch (Exception e){
            return false;
        }
    }
    public  T get(String key,Class clazz){
        try {
            String value = stringRedisTemplate.opsForValue().get(key);

            return stringToBean(value,clazz);
        }catch (Exception e){
            return null ;
        }
    }

    @SuppressWarnings("unchecked")
    private  T stringToBean(String value, Class clazz) {
        if(value==null||value.length()<=0||clazz==null){
            return null;
        }

        if(clazz ==int.class ||clazz==Integer.class){
            return (T)Integer.valueOf(value);
        }
        else if(clazz==long.class||clazz==Long.class){
            return (T)Long.valueOf(value);
        }
        else if(clazz==String.class){
            return (T)value;
        }else {
            return JSON.toJavaObject(JSON.parseObject(value),clazz);
        }
    }

    /**
     *
     * @param Every T values
     * @param T 任意类型
     * @return String
     */
    private  String beanToString(T value) {

        if(value==null){
            return null;
        }
        Class  clazz = value.getClass();
        if(clazz==int.class||clazz==Integer.class){
            return ""+value;
        }
        else if(clazz==long.class||clazz==Long.class){
            return ""+value;
        }
        else if(clazz==String.class){
            return (String)value;
        }else {
            return JSON.toJSONString(value);
        }
    }}

测试代码

  @Autowired
    RedisTemplateService redisTemplateService;
    @Test
    public void redisTest(){

        User user = new User();
        user.setId(11);
        user.setUsername("test");
        user.setPassword("hello redis");
        redisTemplateService.set("key1",user);

        User us = redisTemplateService.get("key1",User.class);
        System.out.println(us.getUsername()+":  "+us.getPassword());
    }

测试结果如下


image.png


image.png

这样，我们就很方便的对redis进行操作，当然这也只是入门级别的应用，后续会持续更新。


无需指教
4楼 · 2021-01-14 08:47

REmote DIctionary Server(Redis) 是一个由Salvatore Sanfilippo写的key-value存储系统。
Redis是一个开源的使用ANSI C语言编写、遵守BSD协议、支持网络、可基于内存亦可持久化的日志型、Key-Value数据库，并提供多种语言的API。
它通常被称为数据结构服务器，因为值（value）可以是 字符串(String), 哈希(Map), 列表(list), 集合(sets) 和 有序集合(sorted sets)等类型。
reids的优点

以下是Redis的一些优点。

异常快 - Redis非常快，每秒可执行大约110000次的设置(SET)操作，每秒大约可执行81000次的读取/获取(GET)操作。
支持丰富的数据类型 - Redis支持开发人员常用的大多数数据类型，例如列表，集合，排序集和散列等等。这使得Redis很容易被用来解决各种问题，因为我们知道哪些问题可以更好使用地哪些数据类型来处理解决。
操作具有原子性 - 所有Redis操作都是原子操作，这确保如果两个客户端并发访问，Redis服务器能接收更新的值。
多实用工具 - Redis是一个多实用工具，可用于多种用例，如：缓存，消息队列(Redis本地支持发布/订阅)，应用程序中的任何短期数据，例如，web应用程序中的会话，网页命中计数等。

Redis 安装

Window 下安装
下载地址：https://github.com/MSOpenTech/redis/releases。
Redis 支持 32 位和 64 位。这个需要根据你系统平台的实际情况选择，这里我们下载 Redis-x64-xxx.zip压缩包到 C 盘，解压后，将文件夹重新命名为 redis。

打开一个 cmd 窗口 使用cd命令切换目录到 C:\redis
运行 redis-server.exe redis.windows.conf
如果想方便的话，可以把 redis 的路径加到系统的环境变量里，这样就省得再输路径了，后面的那个 redis.windows.conf 可以省略，如果省略，会启用默认的。输入之后，会显示如下界面：
在这里插入图片描述

集成redis

我们还是延用上一章的项目：Springboot集成springcloud-config实现dataSource热部署

1、添加依赖



    org.springframework.boot
    spring-boot-starter-redis
    1.4.1.RELEASE


    com.alibaba
    fastjson
    1.2.3


    com.fasterxml.jackson.core
    jackson-databind
123456789101112131415

2、在配置中心里添加redis配置

spring.redis.host=127.0.0.1
#Redis服务器连接端口
spring.redis.port=6379
#Redis服务器连接密码（默认为空）
spring.redis.password=
#连接池最大连接数（使用负值表示没有限制）
spring.redis.pool.max-active=8
#连接池最大阻塞等待时间（使用负值表示没有限制）
spring.redis.pool.max-wait=-1
#连接池中的最大空闲连接
spring.redis.pool.max-idle=8
#连接池中的最小空闲连接
spring.redis.pool.min-idle=0
#连接超时时间（毫秒）
spring.redis.timeout=30000123456789101112131415

3、配置类RedisConfig

import java.lang.reflect.Method;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.cache.CacheManager;
import org.springframework.cache.annotation.CachingConfigurerSupport;
import org.springframework.cache.annotation.EnableCaching;
import org.springframework.cache.interceptor.KeyGenerator;
import org.springframework.cloud.context.config.annotation.RefreshScope;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.cache.RedisCacheManager;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.connection.jedis.JedisConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;
import com.fasterxml.jackson.annotation.PropertyAccessor; 
import com.fasterxml.jackson.annotation.JsonAutoDetect;
import com.fasterxml.jackson.databind.ObjectMapper;
@Configuration
@EnableCaching
@RefreshScope
public class RedisConfig extends CachingConfigurerSupport{
    @Value("${spring.redis.host}")
    private String host;
    @Value("${spring.redis.port}")
    private int port;
    @Value("${spring.redis.timeout}")
    private int timeout;
    @Value("${spring.redis.password}")
    private String password;
    @Value("${spring.redis.pool.max-active}")
    private int maxActive;
    @Value("${spring.redis.pool.max-wait}")
    private int maxWait;
    @Value("${spring.redis.pool.max-idle}")
    private int maxIdle;
    @Value("${spring.redis.pool.min-idle}")
    private int minIdle;
    
    @RefreshScope
    @Bean
    public KeyGenerator wiselyKeyGenerator(){
        return new KeyGenerator() {
            @Override
            public Object generate(Object target, Method method, Object... params) {
                StringBuilder sb = new StringBuilder();
                sb.append(target.getClass().getName());
                sb.append(method.getName());
                for (Object obj : params) {
                    sb.append(obj.toString());
                }
                return sb.toString();
            }
        };
    }
    
    @RefreshScope
    @Bean
    public JedisConnectionFactory redisConnectionFactory() {
        JedisConnectionFactory factory = new JedisConnectionFactory();
        factory.setHostName(host);
        factory.setPort(port);
        factory.setTimeout(timeout); //设置连接超时时间
        factory.setPassword(password);
        factory.getPoolConfig().setMaxIdle(maxIdle);
        factory.getPoolConfig().setMinIdle(minIdle);
        factory.getPoolConfig().setMaxTotal(maxActive);
        factory.getPoolConfig().setMaxWaitMillis(maxWait);
        return factory;
    }
    
    @RefreshScope
    @Bean
    public CacheManager cacheManager(RedisTemplate redisTemplate) {
        RedisCacheManager cacheManager = new RedisCacheManager(redisTemplate);
        // Number of seconds before expiration. Defaults to unlimited (0)
        cacheManager.setDefaultExpiration(10); //设置key-value超时时间
        return cacheManager;
    }
    
    @RefreshScope
    @Bean
    public RedisTemplate redisTemplate(RedisConnectionFactory factory) {
        StringRedisTemplate template = new StringRedisTemplate(factory);
        setSerializer(template); //设置序列化工具，这样ReportBean不需要实现Serializable接口
        template.afterPropertiesSet();
        return template;
    }
    
    @RefreshScope
    private void setSerializer(StringRedisTemplate template) {
        Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer(Object.class);
        ObjectMapper om = new ObjectMapper();
        om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
        om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
        jackson2JsonRedisSerializer.setObjectMapper(om);
        template.setValueSerializer(jackson2JsonRedisSerializer);
    }
}123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899

4、RedisUtils类

import java.io.Serializable;
import java.util.List;
import java.util.Set;
import java.util.concurrent.TimeUnit;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.HashOperations;
import org.springframework.data.redis.core.ListOperations;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.SetOperations;
import org.springframework.data.redis.core.ValueOperations;
import org.springframework.data.redis.core.ZSetOperations;
import org.springframework.stereotype.Service;
@Service
public class RedisUtils {
    @Autowired
    private RedisTemplate redisTemplate;
    /**
     * 写入缓存
     * @param key
     * @param value
     * @return
     */
    public boolean set(final String key, Object value) {
        boolean result = false;
        try {
            ValueOperations operations = redisTemplate.opsForValue();
            operations.set(key, value);
            result = true;
        } catch (Exception e) {
            e.printStackTrace();
        }
        return result;
    }
    /**
     * 写入缓存设置时效时间
     * @param key
     * @param value
     * @return
     */
    public boolean set(final String key, Object value, Long expireTime ,TimeUnit timeUnit) {
        boolean result = false;
        try {
            ValueOperations operations = redisTemplate.opsForValue();
            operations.set(key, value);
            redisTemplate.expire(key, expireTime, timeUnit);
            result = true;
        } catch (Exception e) {
            e.printStackTrace();
        }
        return result;
    }
    /**
     * 批量删除对应的value
     * @param keys
     */
    public void remove(final String... keys) {
        for (String key : keys) {
            remove(key);
        }
    }
    /**
     * 批量删除key
     * @param pattern
     */
    public void removePattern(final String pattern) {
        Set keys = redisTemplate.keys(pattern);
        if (keys.size() > 0){
            redisTemplate.delete(keys);
        }
    }
    /**
     * 删除对应的value
     * @param key
     */
    public void remove(final String key) {
        if (exists(key)) {
            redisTemplate.delete(key);
        }
    }
    /**
     * 判断缓存中是否有对应的value
     * @param key
     * @return
     */
    public boolean exists(final String key) {
        return redisTemplate.hasKey(key);
    }
    /**
     * 读取缓存
     * @param key
     * @return
     */
    public Object get(final String key) {
        Object result = null;
        ValueOperations operations = redisTemplate.opsForValue();
        result = operations.get(key);
        return result;
    }
    /**
     * 哈希 添加
     * @param key
     * @param hashKey
     * @param value
     */
    public void hmSet(String key, Object hashKey, Object value){
        HashOperations hash = redisTemplate.opsForHash();
        hash.put(key,hashKey,value);
    }
    /**
     * 哈希获取数据
     * @param key
     * @param hashKey
     * @return
     */
    public Object hmGet(String key, Object hashKey){
        HashOperations  hash = redisTemplate.opsForHash();
        return hash.get(key,hashKey);
    }
    /**
     * 列表添加
     * @param k
     * @param v
     */
    public void lPush(String k,Object v){
        ListOperations list = redisTemplate.opsForList();
        list.rightPush(k,v);
    }
    /**
     * 列表获取
     * @param k
     * @param l
     * @param l1
     * @return
     */
    public List lRange(String k, long l, long l1){
        ListOperations list = redisTemplate.opsForList();
        return list.range(k,l,l1);
    }
    /**
     * 集合添加
     * @param key
     * @param value
     */
    public void add(String key,Object value){
        SetOperations set = redisTemplate.opsForSet();
        set.add(key,value);
    }
    /**
     * 集合获取
     * @param key
     * @return
     */
    public Set setMembers(String key){
        SetOperations set = redisTemplate.opsForSet();
        return set.members(key);
    }
    /**
     * 有序集合添加
     * @param key
     * @param value
     * @param scoure
     */
    public void zAdd(String key,Object value,double scoure){
        ZSetOperations zset = redisTemplate.opsForZSet();
        zset.add(key,value,scoure);
    }
    /**
     * 有序集合获取
     * @param key
     * @param scoure
     * @param scoure1
     * @return
     */
    public Set rangeByScore(String key,double scoure,double scoure1){
        ZSetOperations zset = redisTemplate.opsForZSet();
        return zset.rangeByScore(key, scoure, scoure1);
    }123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177
5、测试，修改controller
import java.util.concurrent.TimeUnit;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import com.chenqi.springboot.redis.RedisUtils;
import com.chenqi.springboot.service.TestService;
@RestController
public class SpringBootController {
    
    public static final Logger log = LoggerFactory.getLogger(SpringBootController.class);
    
    @Autowired
    TestService testService;
    
    @Autowired
    private RedisUtils redisUtils;
    @RequestMapping(value = "/hello/{id}")
    public String hello(@PathVariable(value = "id") String id){
        //查询缓存中是否存在
        boolean hasKey = redisUtils.exists(id);
        String str = "";
        if(hasKey){
            //获取缓存
            Object object =  redisUtils.get(id);
            log.info("从缓存获取的数据"+ object);
            str = object.toString();
        }else{
            //从数据库中获取信息
            log.info("从数据库中获取数据");
            str = testService.test();
            //数据插入缓存（set中的参数含义：key值，user对象，缓存存在时间10（long类型），时间单位）
            redisUtils.set(id,str,10L,TimeUnit.MINUTES);
            log.info("数据插入缓存" + str);
        }
        return str;
    }
}12345678910111213141516171819202122232425262728293031323334353637383940
启动项目，第一次访问：http://localhost:8002/hello/111
在这里插入图片描述
在这里插入图片描述
通过控制台输出，我们可以看到是从数据库中获取的数据，并且存入了redis缓存中。
我们再次刷新浏览器
在这里插入图片描述
可以看到，第二次是从缓存中读取的，我们试试不断刷新浏览器
在这里插入图片描述
可以看到，之后都是从缓存中获取的。
到此我们的redis就配置好了。

                                                                    

                                                        

            

             

             




                

                
                  
                





         
            

            

                                  

            
            
            
            

            
            小小邓                                          
            
             

             5楼 · 2021-01-14 10:40
             

             

             

                          

             

                                                                          
Redis是一个开源的使用ANSI C语言编写、遵守BSD协议、支持网络、可基于内存亦可持久化的日志型、Key-Value数据库，并提供多种语言的API
                                                                    

                                                        

            


             

             




                

                

                  
                







         
            

            

                                  

            
            
            
            

            
            Kindery                                          
            
             

             6楼 · 2021-01-14 13:39
             

             

             

                          

             

                                                                          
异常快 - Redis非常快，每秒可执行大约110000次的设置(SET)操作，每秒大约可执行81000次的读取/获取(GET)操作。
支持丰富的数据类型 - Redis支持开发人员常用的大多数数据类型，例如列表，集合，排序集和散列等等。这使得Redis很容易被用来解决各种问题，因为我们知道哪些问题可以更好使用地哪些数据类型来处理解决。
操作具有原子性 - 所有Redis操作都是原子操作，这确保如果两个客户端并发访问，Redis服务器能接收更新的值。
多实用工具 - Redis是一个多实用工具，可用于多种用例，如：缓存，消息队列(Redis本地支持发布/订阅)，应用程序中的任何短期数据，例如，web应用程序中的会话，网页命中计数等。
                                                                    

                                                        

            


             

             




                

                

                  
                







         
            

            

                                  

            
            
            
            

            
            freediandianer                                          
            
             

             7楼 · 2021-01-14 15:45
             

             

             

                          

             

                                                                          
1.对于配置文件,网上很多,您可以直接拿来即可使用。当然,您也可以自己写一个配...
2.需要配置redis的端口,这个端口是您安装redis时候可以设置的,如果您的r...
3.还有几个主要的参数,这要这些参数全部配置完后,基本的配置就结束了。
4.读这些配置文件。
5.在文件中创建读取配置文件。

                                                                    

                                                        

            


             

             




                

                

                  
                







         
            

            

                                  

            
            
            
            

            
            像风没有归宿                                          
            
             

             8楼 · 2021-01-14 18:21
             

             

             

                          

             

                                                                          
1
# Redis数据库索引（默认为0）
2
spring.redis.database=0
3
# Redis服务器地址
4
spring.redis.host=192.168.0.24
5
# Redis服务器连接端口
6
spring.redis.port=6379
7
# Redis服务器连接密码（默认为空）
8
spring.redis.password=
9
# 连接池最大连接数（使用负值表示没有限制）
10
spring.redis.pool.max-active=200
11
# 连接池最大阻塞等待时间（使用负值表示没有限制）
12
spring.redis.pool.max-wait=-1
13
# 连接池中的最大空闲连接
14
spring.redis.pool.max-idle=10
15
# 连接池中的最小空闲连接
16
spring.redis.pool.min-idle=0
17
# 连接超时时间（毫秒）
18
spring.redis.timeout=1000

                                                                    

                                                        

            


             

             




                

                

                  
                







         
            

            

                                  

            
            
            
            

            
            爱学习的小巴                                          
            
             

             9楼 · 2021-01-15 10:20
             

             

             

                          

             

                                                                          
REmote DIctionary Server(Redis) 是一个由Salvatore Sanfilippo写的key-value存储系统。
Redis是一个开源的使用ANSI C语言编写、遵守BSD协议、支持网络、可基于内存亦可持久化的日志型、Key-Value数据库，并提供多种语言的API。
它通常被称为数据结构服务器，因为值（value）可以是 字符串(String), 哈希(Map), 列表(list), 集合(sets) 和 有序集合(sorted sets)等类型。
                                                                    

                                                        

            


             

             




                

                

                  
                








1
2
3
下一页










		
				





相关问题推荐



  • 

    
execute，executeQuery，exec2020-06-04 10:58

    

    

    回答 2
    

    

    Statement的execute(String query)方法用来执行任意的SQL查询，如果查询的结果是一个ResultSet，这个方法就返回true。如果结果不是ResultSet，比如insert或者update查询，它就会返回false。我们可以通过它的getResultSet方法来获取ResultSet，或者通过getUpda...
    

    

  • 

    
学编程真的需要经常加班么？2020-05-18 17:41

    

    

    回答 22
    

    

    忙的时候项目期肯定要加班 但是每天加班应该还不至于
    

    

  • 

    
学Java的人太多了，现在学Java还好找工作吗？2020-03-18 16:57

    

    

    回答 108
    

    已采纳
    

    虽然Java人才越来越多，但是人才缺口也是很大的，我国对JAVA工程师的需求是所有软件工程师当中需求大的，达到全部需求量的60%-70%，所以Java市场在短时间内不可能饱和。其次，Java市场不断变化，人才需求也会不断增加。马云说过，未来的制造业要的不是石油，...
    

    

  • 

    
工信部证书的含金量如何？2020-05-11 11:08

    

    

    回答 5
    

    已采纳
    

    工信部证书含金量较高。工信部是国务院的下属结构，具有发放资质、证书的资格。其所发放的证书具有较强的权威性，在全国范围内收到认可，含金量通常都比较高。
工信部证书，其含义也就是工信部颁发并承认的某项技能证书，是具有法律效力的，并且是国家认可的...
    

    

  • 

    
学java有好找工作么？2020-08-13 18:38

    

    

    回答 70
    

    已采纳
    

    学Java好不好找工作？看学完Java后能做些什么吧。一、大数据技术Hadoop以及其他大数据处理技术都是用Java或者其他，例如Apache的基于Java 的 HBase和Accumulo以及ElasticSearchas。但是Java在此领域并未占太大空间，但只要Hadoop和ElasticSearchas能够成长壮...
    

    

  • 

    
java中的八股文指的是什么？2021-05-17 08:45

    

    

    回答 16
    

    已采纳
    

    就是java的基础知识啊，比如Java 集合框架；Java 多线程；线程的五种状态；Java 虚拟机；MySQL （InnoDB）；Spring 相关；计算机网络；MQ 消息队列诸如此类
    

    

  • 

    
#{}和${}的区别是什么？2020-06-15 09:21

    

    

    回答 12
    

    

    #{}和${}这两个语法是为了动态传递参数而存在的，是Mybatis实现动态SQL的基础，总体上他们的作用是一致的（为了动态传参），但是在编译过程、是否自动加单引号、安全性、使用场景等方面有很多不同，下面详细比较两者间的区别：1.#{} 是 占位符 ：动态解析 ...
    

    

  • 

    
专科做java可以就业吗？2021-08-19 16:15

    

    

    回答 62
    

    

    没问题的，专科学历也能学习Java开发的，主要看自己感不感兴趣，只要认真学，市面上的培训机构不少都是零基础课程，能跟得上，或是自己先找些资料学习一下。
    

    

  • 

    
单例可能被破坏的场景有哪些？单例模式
2022-05-07 18:07

    

    

    回答 4
    

    

    1、反射对单例模式的破坏采用反射的方式另辟蹊径实例了该类，导致程序中会存在不止一个实例。解决方案其思想就是采用一个全局变量，来标记是否已经实例化过了，如果已经实例化过了，第 二次实例化的时候，抛出异常2、clone()对单例模式的破坏当需要实现单例的...
    

    

  • 

    
单例模式的优缺点单例模式
2022-05-07 18:04

    

    

    回答 5
    

    

     优点: 一、实例控制  单例模式会阻止其他对象实例化其自己的单例对象的副本，从而确保所有对象都访问唯一实例。 二、灵活性  因为类控制了实例化过程，所以类可以灵活更改实例化过程。 缺点: 一、开销  虽然数量很少，但如果每次对象请求引用时都要...
    

    

  • 

    
哈希表的p怎么取得哈希表
2022-04-20 18:51

    

    

    回答 4
    

    

    这个主要是看你数组的长度是多少， 比如之前写过的一个程序有个数组存的是各个客户端的ip地址：string clientIp[4]={XXX, xxx, xxx, xxx};这个时候如果想把hash值对应到上面四个地址的话，就应该对4取余，这个时候p就应该为4...
    

    

  • 

    
哈希表的key存在什么地方哈希表
2022-04-20 18:51

    

    

    回答 6
    

    

     哈希表的大小 · 关键字的分布情况 · 记录的查找频率 1.直接寻址法：取关键字或关键字的某个线性函数值为散列地址。即H(key)=key或H(key) = a·key + b，其中a和b为常数（这种散列函数叫做自身函数）。...
    

    

  • 

    
为什么哈希表的长度应该是质数？哈希表
2022-04-02 16:41

    

    

    回答 6
    

    

    哈希表的大小取决于一组质数,原因是在hash函数中,你要用这些质数来做模运算(%)。而分析发现,如果不是用质数来做模运算的话,很多生活中的数据分布,会集中在某些点上。所以这里最后采用了质数做模的除数。 因为用质数做了模的除数,自然存储空间的大小也用质数了...
    

    

  • 

    
哈希表的实现需要预先开启出一块内存空间？哈希表
2022-04-02 16:07

    

    

    回答 2
    

    

    是啊，哈希函数的设计至关重要,好的哈希函数会尽可能地保证计算简单和散列地址分布均匀,但是,我们需要清楚的是,数组是一块连续的固定长度的内存空间
    

    

  • 

    
哈希表优化的方法有哪些？哈希表
2022-04-01 18:53

    

    

    回答 3
    

    

     解码查表优化算法，seo优化
    

    

  • 

    
哈希表的原理是什么？哈希表
2022-04-01 18:52

    

    

    回答 5
    

    

    1.对对象元素中的关键字(对象中的特有数据),进行哈希算法的运算,并得出一个具体的算法值,这个值 称为哈希值。2.哈希值就是这个元素的位置。3.如果哈希值出现冲突,再次判断这个关键字对应的对象是否相同。如果对象相同,就不存储,因为元素重复。如果对象不同,就...
    

    



没有解决我的问题，去提问



















































    
    
   


  
  • 
    
    
    •