網路流24題 P2765 魔術球問題

1、redis自動化配置
原始碼分析：RedisAutoConfiguration

@Configuration(
proxyBeanMethods = false
)
@ConditionalOnClass({RedisOperations.class})
@EnableConfigurationProperties({RedisProperties.class})
@Import({LettuceConnectionConfiguration.class, JedisConnectionConfiguration.class})
public class RedisAutoConfiguration {
public RedisAutoConfiguration() {
}

@Bean
@ConditionalOnMissingBean(name = {"redisTemplate"})	//當次例項不存在時生效
public RedisTemplate<Object, Object> redisTemplate(RedisConnectionFactory redisConnectionFactory) throws UnknownHostException {
	//預設的restTemplate，沒有過多的設定，開發過程中物件需要序列化，可以自定義RedisTemplate
    RedisTemplate<Object, Object> template = new RedisTemplate();
    template.setConnectionFactory(redisConnectionFactory);
    return template;
}

@Bean
@ConditionalOnMissingBean	//由於String型別最常用，所以單獨提出來了一個Bean
public StringRedisTemplate stringRedisTemplate(RedisConnectionFactory redisConnectionFactory) throws UnknownHostException {
    StringRedisTemplate template = new StringRedisTemplate();
    template.setConnectionFactory(redisConnectionFactory);
    return template;
}

}
springboot整合redis
1、匯入依賴：
Springboot2.x 以後使用lettuce來作為redis的客戶端來進行連線

    <!-- spring boot redis 快取引入 -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-data-redis</artifactId>
    </dependency>
    <!-- lettuce pool 快取連線池 -->
    <dependency>
        <groupId>org.apache.commons</groupId>
        <artifactId>commons-pool2</artifactId>
    </dependency>

2、yml配置：
server:
port: 8989
spring:
redis:
host: luliang888.top
port: 6379
# 密碼沒有則可以不填
password: 123456
# 如果使用的jedis 則將lettuce改成jedis即可
lettuce:
pool:
# 最大活躍連結數預設8
max-active: 8
# 最大空閒連線數預設8
max-idle: 8
# 最小空閒連線數預設0
min-idle: 0
3、RedisConfig配置
@Configuration
public class RedisConfig {
/**
* 自定義RedisTemplate ，序列化
* @param redisConnectionFactory
* @return
* @throws UnknownHostException
*/
@Bean
public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory redisConnectionFactory) {
// 我們為了自己開發方便，一般直接使用 <String, Object>
RedisTemplate<String, Object> template = new RedisTemplate<>();
template.setConnectionFactory(redisConnectionFactory);

    // Json序列化配置
    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);

    // String 的序列化
    StringRedisSerializer stringRedisSerializer = new StringRedisSerializer();
    // key採用String的序列化方式
    template.setKeySerializer(stringRedisSerializer);
    // hash的key也採用String的序列化方式
    template.setHashKeySerializer(stringRedisSerializer);
    // value序列化方式採用jackson
    template.setValueSerializer(jackson2JsonRedisSerializer);
    // hash的value序列化方式採用jackson
    template.setHashValueSerializer(jackson2JsonRedisSerializer);
    template.afterPropertiesSet();
    return template;
}

}
4、自定義工具類
package com.kuang.utils;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Component;
import org.springframework.util.CollectionUtils;

import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.TimeUnit;

// 在我們真實的分發中，或者你們在公司，一般都可以看到一個公司自己封裝RedisUtil
@Component
public final class RedisUtil {

@Autowired
private RedisTemplate<String, Object> redisTemplate;

// =============================common============================
/**
 * 指定快取失效時間
 * @param key  鍵
 * @param time 時間(秒)
 */
public boolean expire(String key, long time) {
    try {
        if (time > 0) {
            redisTemplate.expire(key, time, TimeUnit.SECONDS);
        }
        return true;
    } catch (Exception e) {
        e.printStackTrace();
        return false;
    }
}

/**
 * 根據key 獲取過期時間
 * @param key 鍵 不能為null
 * @return 時間(秒) 返回0代表為永久有效
 */
public long getExpire(String key) {
    return redisTemplate.getExpire(key, TimeUnit.SECONDS);
}


/**
 * 判斷key是否存在
 * @param key 鍵
 * @return true 存在 false不存在
 */
public boolean hasKey(String key) {
    try {
        return redisTemplate.hasKey(key);
    } catch (Exception e) {
        e.printStackTrace();
        return false;
    }
}


/**
 * 刪除快取
 * @param key 可以傳一個值 或多個
 */
@SuppressWarnings("unchecked")
public void del(String... key) {
    if (key != null && key.length > 0) {
        if (key.length == 1) {
            redisTemplate.delete(key[0]);
        } else {
            redisTemplate.delete(CollectionUtils.arrayToList(key));
        }
    }
}


// ============================String=============================

/**
 * 普通快取獲取
 * @param key 鍵
 * @return 值
 */
public Object get(String key) {
    return key == null ? null : redisTemplate.opsForValue().get(key);
}

/**
 * 普通快取放入
 * @param key   鍵
 * @param value 值
 * @return true成功 false失敗
 */

public boolean set(String key, Object value) {
    try {
        redisTemplate.opsForValue().set(key, value);
        return true;
    } catch (Exception e) {
        e.printStackTrace();
        return false;
    }
}


/**
 * 普通快取放入並設定時間
 * @param key   鍵
 * @param value 值
 * @param time  時間(秒) time要大於0 如果time小於等於0 將設定無限期
 * @return true成功 false 失敗
 */

public boolean set(String key, Object value, long time) {
    try {
        if (time > 0) {
            redisTemplate.opsForValue().set(key, value, time, TimeUnit.SECONDS);
        } else {
            set(key, value);
        }
        return true;
    } catch (Exception e) {
        e.printStackTrace();
        return false;
    }
}


/**
 * 遞增
 * @param key   鍵
 * @param delta 要增加幾(大於0)
 */
public long incr(String key, long delta) {
    if (delta < 0) {
        throw new RuntimeException("遞增因子必須大於0");
    }
    return redisTemplate.opsForValue().increment(key, delta);
}


/**
 * 遞減
 * @param key   鍵
 * @param delta 要減少幾(小於0)
 */
public long decr(String key, long delta) {
    if (delta < 0) {
        throw new RuntimeException("遞減因子必須大於0");
    }
    return redisTemplate.opsForValue().increment(key, -delta);
}


// ================================Map=================================

/**
 * HashGet
 * @param key  鍵 不能為null
 * @param item 項 不能為null
 */
public Object hget(String key, String item) {
    return redisTemplate.opsForHash().get(key, item);
}

/**
 * 獲取hashKey對應的所有鍵值
 * @param key 鍵
 * @return 對應的多個鍵值
 */
public Map<Object, Object> hmget(String key) {
    return redisTemplate.opsForHash().entries(key);
}

/**
 * HashSet
 * @param key 鍵
 * @param map 對應多個鍵值
 */
public boolean hmset(String key, Map<String, Object> map) {
    try {
        redisTemplate.opsForHash().putAll(key, map);
        return true;
    } catch (Exception e) {
        e.printStackTrace();
        return false;
    }
}


/**
 * HashSet 並設定時間
 * @param key  鍵
 * @param map  對應多個鍵值
 * @param time 時間(秒)
 * @return true成功 false失敗
 */
public boolean hmset(String key, Map<String, Object> map, long time) {
    try {
        redisTemplate.opsForHash().putAll(key, map);
        if (time > 0) {
            expire(key, time);
        }
        return true;
    } catch (Exception e) {
        e.printStackTrace();
        return false;
    }
}


/**
 * 向一張hash表中放入資料,如果不存在將建立
 *
 * @param key   鍵
 * @param item  項
 * @param value 值
 * @return true 成功 false失敗
 */
public boolean hset(String key, String item, Object value) {
    try {
        redisTemplate.opsForHash().put(key, item, value);
        return true;
    } catch (Exception e) {
        e.printStackTrace();
        return false;
    }
}

/**
 * 向一張hash表中放入資料,如果不存在將建立
 *
 * @param key   鍵
 * @param item  項
 * @param value 值
 * @param time  時間(秒) 注意:如果已存在的hash表有時間,這裡將會替換原有的時間
 * @return true 成功 false失敗
 */
public boolean hset(String key, String item, Object value, long time) {
    try {
        redisTemplate.opsForHash().put(key, item, value);
        if (time > 0) {
            expire(key, time);
        }
        return true;
    } catch (Exception e) {
        e.printStackTrace();
        return false;
    }
}


/**
 * 刪除hash表中的值
 *
 * @param key  鍵 不能為null
 * @param item 項 可以使多個 不能為null
 */
public void hdel(String key, Object... item) {
    redisTemplate.opsForHash().delete(key, item);
}


/**
 * 判斷hash表中是否有該項的值
 *
 * @param key  鍵 不能為null
 * @param item 項 不能為null
 * @return true 存在 false不存在
 */
public boolean hHasKey(String key, String item) {
    return redisTemplate.opsForHash().hasKey(key, item);
}


/**
 * hash遞增 如果不存在,就會建立一個 並把新增後的值返回
 *
 * @param key  鍵
 * @param item 項
 * @param by   要增加幾(大於0)
 */
public double hincr(String key, String item, double by) {
    return redisTemplate.opsForHash().increment(key, item, by);
}


/**
 * hash遞減
 *
 * @param key  鍵
 * @param item 項
 * @param by   要減少記(小於0)
 */
public double hdecr(String key, String item, double by) {
    return redisTemplate.opsForHash().increment(key, item, -by);
}


// ============================set=============================

/**
 * 根據key獲取Set中的所有值
 * @param key 鍵
 */
public Set<Object> sGet(String key) {
    try {
        return redisTemplate.opsForSet().members(key);
    } catch (Exception e) {
        e.printStackTrace();
        return null;
    }
}


/**
 * 根據value從一個set中查詢,是否存在
 *
 * @param key   鍵
 * @param value 值
 * @return true 存在 false不存在
 */
public boolean sHasKey(String key, Object value) {
    try {
        return redisTemplate.opsForSet().isMember(key, value);
    } catch (Exception e) {
        e.printStackTrace();
        return false;
    }
}


/**
 * 將資料放入set快取
 *
 * @param key    鍵
 * @param values 值 可以是多個
 * @return 成功個數
 */
public long sSet(String key, Object... values) {
    try {
        return redisTemplate.opsForSet().add(key, values);
    } catch (Exception e) {
        e.printStackTrace();
        return 0;
    }
}


/**
 * 將set資料放入快取
 *
 * @param key    鍵
 * @param time   時間(秒)
 * @param values 值 可以是多個
 * @return 成功個數
 */
public long sSetAndTime(String key, long time, Object... values) {
    try {
        Long count = redisTemplate.opsForSet().add(key, values);
        if (time > 0)
            expire(key, time);
        return count;
    } catch (Exception e) {
        e.printStackTrace();
        return 0;
    }
}


/**
 * 獲取set快取的長度
 *
 * @param key 鍵
 */
public long sGetSetSize(String key) {
    try {
        return redisTemplate.opsForSet().size(key);
    } catch (Exception e) {
        e.printStackTrace();
        return 0;
    }
}


/**
 * 移除值為value的
 *
 * @param key    鍵
 * @param values 值 可以是多個
 * @return 移除的個數
 */

public long setRemove(String key, Object... values) {
    try {
        Long count = redisTemplate.opsForSet().remove(key, values);
        return count;
    } catch (Exception e) {
        e.printStackTrace();
        return 0;
    }
}

// ===============================list=================================

/**
 * 獲取list快取的內容
 *
 * @param key   鍵
 * @param start 開始
 * @param end   結束 0 到 -1代表所有值
 */
public List<Object> lGet(String key, long start, long end) {
    try {
        return redisTemplate.opsForList().range(key, start, end);
    } catch (Exception e) {
        e.printStackTrace();
        return null;
    }
}


/**
 * 獲取list快取的長度
 *
 * @param key 鍵
 */
public long lGetListSize(String key) {
    try {
        return redisTemplate.opsForList().size(key);
    } catch (Exception e) {
        e.printStackTrace();
        return 0;
    }
}


/**
 * 通過索引 獲取list中的值
 *
 * @param key   鍵
 * @param index 索引 index>=0時， 0 表頭，1 第二個元素，依次類推；index<0時，-1，表尾，-2倒數第二個元素，依次類推
 */
public Object lGetIndex(String key, long index) {
    try {
        return redisTemplate.opsForList().index(key, index);
    } catch (Exception e) {
        e.printStackTrace();
        return null;
    }
}


/**
 * 將list放入快取
 *
 * @param key   鍵
 * @param value 值
 */
public boolean lSet(String key, Object value) {
    try {
        redisTemplate.opsForList().rightPush(key, value);
        return true;
    } catch (Exception e) {
        e.printStackTrace();
        return false;
    }
}


/**
 * 將list放入快取
 * @param key   鍵
 * @param value 值
 * @param time  時間(秒)
 */
public boolean lSet(String key, Object value, long time) {
    try {
        redisTemplate.opsForList().rightPush(key, value);
        if (time > 0)
            expire(key, time);
        return true;
    } catch (Exception e) {
        e.printStackTrace();
        return false;
    }

}

/**
 * 將list放入快取
 *
 * @param key   鍵
 * @param value 值
 * @return
 */
public boolean lSet(String key, List<Object> value) {
    try {
        redisTemplate.opsForList().rightPushAll(key, value);
        return true;
    } catch (Exception e) {
        e.printStackTrace();
        return false;
    }

}

/**
 * 將list放入快取
 *
 * @param key   鍵
 * @param value 值
 * @param time  時間(秒)
 * @return
 */
public boolean lSet(String key, List<Object> value, long time) {
    try {
        redisTemplate.opsForList().rightPushAll(key, value);
        if (time > 0)
            expire(key, time);
        return true;
    } catch (Exception e) {
        e.printStackTrace();
        return false;
    }
}

/**
 * 根據索引修改list中的某條資料
 *
 * @param key   鍵
 * @param index 索引
 * @param value 值
 * @return
 */
public boolean lUpdateIndex(String key, long index, Object value) {
    try {
        redisTemplate.opsForList().set(key, index, value);
        return true;
    } catch (Exception e) {
        e.printStackTrace();
        return false;
    }
}

/**
 * 移除N個值為value
 *
 * @param key   鍵
 * @param count 移除多少個
 * @param value 值
 * @return 移除的個數
 */
public long lRemove(String key, long count, Object value) {
    try {
        Long remove = redisTemplate.opsForList().remove(key, count, value);
        return remove;
    } catch (Exception e) {
        e.printStackTrace();
        return 0;
    }

}

}

故事——Java帝國的誕生
C & C++
1972年C誕生

貼近硬體，執行極快，效率極高

作業系統、編譯器、資料庫、網路系統等

令人頭疼的兩點：指標和記憶體管理

雖然指標的功能很強大，可以直接操作記憶體，但是C語言並沒有提供記憶體越界檢查的工具，這導致很多程式設計師在寫程式碼時很容易犯錯；

至於記憶體管理，佔用了內容需要自己手動寫程式碼釋放，而且在編譯的過程中是發現不到錯誤的，直到執行起來，才能發現有問題；

1982年C++誕生

面向物件
相容C
圖形領域、遊戲等
反抗
我們要建立一個新的語言：

語法有點像C
沒有指標
沒有記憶體管理
真正的可移植性，編寫一次，到處執行
面向物件
型別安全
高質量的類庫
。。。
Java初生
1995年的頁面簡單而粗糙，缺乏互動性

Java開發出一個圖形介面的程式（Applet）

Java 2 標準版（J2SE）：桌面

Java 2 移動版（J2ME）：手機

Java 2 企業版（J2EE）：伺服器

Java發展
居於Java開發了很多平臺、系統、工具

構建工具：Ant，Maven，Jekins
應用伺服器：Tomcat，Jetty，Jboss，Websphere，weblogic
Web開發：Struts，Spring，Hibernate，Mybatis
開發工具：Eclipse，NetBean，InteIIiJ IDEA，Jbuilder
2006年：Hadoop（大資料領域）

2008年：Android（手機端）

Java特性和優勢
簡單性

面向物件

是一種程式設計技術，關注的重點放在物件以及物件的介面上，模擬人的思維去寫程式，Java中萬物皆物件；

可移植性

Write once，Run anywhere！

高效能

及時編譯功能；

分散式

通過Java能夠實現遠端方法呼叫，獲取網上的資源就如同在本地開啟我的電腦一樣簡單；

動態性

Java自身不具有動態性，但是後面要學一個機制叫反射機制有動態性

多執行緒

安全性

健壯性

Java三大版本
Write once，Run anywhere！

JavaSE：標準版（桌面程式，控制檯開發...）

這是Java的核心

JavaME：嵌入式開發（手機，小家電...）

這塊內容用的不多了

JavaEE：企業級開發（Web，伺服器開發...）

這是目前應用最廣泛的內容，是Java的進階

JDK、JRE、JVM
JDK：Java Development Kit——Java開發工具

JRE：Java Runtime Environment——Java執行時環境

JVM：Java Virtual Machine——Java虛擬機器

Java虛擬機器的作用是遮蔽底層系統的差別，真正實現了一次編譯匯出執行；

安裝開發環境
下載JDK並配置環境變數

Hello World詳解
隨便建立一個資料夾，存放程式碼

新建一個java檔案

檔案字尾名為.java
Hello.java
【注意點】系統可能沒有顯示檔案字尾名，我們需要手動開啟這個設定
編寫程式碼

public class Hello{
public static void main(String[] args){
System.out.print("Hello,World!");
}
}
編譯，會生成一個.class檔案

javac Hello.java
執行.class檔案

java Hello
可能會遇到的問題

每個單詞的大小寫不能有問題，Java是大小寫敏感的
儘量使用英文
檔名和類名必須保證一直，並且首字母大寫
符號使用了中文符號
編譯型和解釋型
從字面意思來看，編譯與解釋都具有翻譯的意思，但是他們兩者的唯一區別就是發生的時機不同；

如果一個美國人想讀《山海經》，他會有兩種選擇：第一、他賣英譯後的《山海經》；第二、他找一箇中英翻譯官，讓翻譯官翻譯一段給他講一段。這個例子https://www.cnblogs.com/iojkl/p/13552737.html

網路流24題 P2765 魔術球問題

網路流24題 P2765 魔術球問題

《網路流24題》（未完待續）

網路流24題

網路流 24 題

題解洛谷P1251 網路流24題.01【餐巾計劃問題】

題解洛谷P4016 網路流24題.03 【負載平衡問題】

題解洛谷P2756 網路流24題.04 【飛行員配對方案問題】

網路流24題 P2764 最小路徑覆蓋問題

網路流24題 P2763 試題庫問題

網路流24題 P2766 最長不下降子序列問題

【網路流24題】 5. 最長不下降子序列問題

【網路流24題】 7. 試題庫問題題解

【網路流24題】 5. 圓桌問題題解

【網路流24題】 9. 方格取數問題題解

「網路流 24 題」負載平衡

網路流24題-圓桌問題

網路流 24 題星際轉移問題

網路流 24 題最長遞增子序列問題

[ZJOI2010]網路擴容[網路流24題]

LibreOJ 6121. 「網路流 24 題」孤島營救問題

網路流24題 P2765 魔術球問題

相關推薦