学习笔记
fn main() {
println!("Hello, world!");
// 变量
let x = 1;
let y: i32 = 16;
println!("{}--{}", x, y);
// 可变变量
// let rust = "rust";
// rust = "dome"; //报错
let mut longInt: i32 = 100;
longInt = 10;
println!("{}", longInt);
// 变量遮掩---可定义上面出现过的变量名，且上面的变量无法
let longInt: String = String::from("张三");
println!("{}", longInt);
// 常量
const MAX: u32 = 1024;
println!("{}", MAX)
}
二，基本数据类型
fn main() {
// ① 整数类型
let rust = 415; // rust 默认是 i32
let intRust8: i8 = 8;
let intRustU8: u8 = 8;
let intRust16: i16 = 16;
let intRustU16: u16 = 16;
let intRust32: i32 = 32;
let intRustU32: u32 = 32;
let intRust64: i64 = 64;
let intRustU64: u64 = 64;
// 有符号和无符号
// 有符号可表示 负数
// 无符号 比有符号多了一个位数，在正整数比无符号的大
// ② 浮点类型
// f32 和 f64 的小数点后面 位数不一样，所表示的精度也不一样
// f64精度高
let float32: f32 = 32.3200;
let float64: f64 = 64.6400;
// ③ 布尔型
let f: bool = false;
let t: bool = true;
// ④字符类型
// 字符类型是unicode值，char类型的
// 不是string类型
let z = 'z';
let zz = '*';
// ⑤范围类型
let aa = 1..5;
let bb = 1..100;
for i in aa {
println!("{}", i);
}
}
三，复合数据类型
#[derive(Debug)]
struct Info {
name: String,
age: i32,
}
#[derive(Debug)]
enum ColorNoParam {
Red,
Yellow,
Name(String),
}
fn main() {
// ①元组类型
// 元组类型是由（）包裹起来，元素直接使用，隔开
let temp = (1, 2, 3, 4, 5);
let temp1: (i32, bool, &str) = (10, false, "111");
println!("{}--{}", temp.1, temp1.2); // 2--111
//② 数组类型
let arr: [i32; 5] = [1, 2, 3, 4, 5];
let arr1 = [1, 2, 3];
let arr2 = [1; 5];
println!("{:?}", arr); //[1, 2, 3, 4, 5]
println!("{:?}", arr1); // [1, 2, 3]
println!("{:?}", arr2); //[1, 1, 1, 1, 1]
println!("{:?}--{}", arr.get(0), arr[2]);
println!("{:?}", arr.get(10)); // None
// 用 .get 安全些 不会出现 取值越界出错的情况
// ③结构体数据类型
// &'static str 这个是 引用类型的字符串，跟着程序销毁而销毁 少写
let userinfo: Info = Info {
name: String::from("张三"),
age: 24,
};
println!("{}", userinfo.name); // 张三
println!("{:#?}", userinfo); // Info {name: "张三", age: 24, }
let user = Info {
name: String::from("李四"),
..userinfo // 类似继承上一个结构体数据
};
println!("{}", user.name); // 李四
println!("{:?}", user); // Info {name: "李四", age: 24, }
// ④枚举类型
let color_no_param = ColorNoParam::Name(String::from("张三"));
println!("{:?}", color_no_param); //Name("张三")
match color_no_param {
ColorNoParam::Red => println!("red色"),
ColorNoParam::Yellow => println!("黄色"),
ColorNoParam::Name(name) => {
println!("{}-----", name)
}
_ => {}
}
}
四，容器类型
use std::collections::{HashMap, VecDeque};
fn main() {
// rust 提供了 4种通用容器类型
// 线性序列 : Vec<T> 连续可变数组，VecDeque<T>连续存储的可变双端队列，LinkedList<T>非连续存储的双向链表
// 键值对 : HashMap<K,V> 哈希表的无序键-值对，BTreeMap<K,V> 基于B树的有序键值对按key排序
// 集合 : HashSet<T> 基于哈希表的无序集合，BTreeSet<T> 基于B树的有序集合
// 优先队列 : BinaryHeap<T>基于二叉堆的优先队列
// ① Vec<T> 是动态可变的数组
// 定义 Vec<T> 动态数组
let mut _v_list: Vec<i32> = Vec::new(); // 创建空的动态数组
let mut _v_list1: Vec<i32> = Vec::with_capacity(10); // 创建指定容量的动态数组，数组扩容会消耗资源,建议初始化动态数组的时候合理分配动态数组大小
let mut _v_list2: Vec<i32> = vec![1, 2, 3]; // 通过 vec! 宏的方式 创建动态数组
let mut _v_list3 = vec![1, 2, 3]; // 类型推到了省掉了 定义类型
// 添加元素
println!("{:?}", _v_list); // []
_v_list.push(10);
_v_list.push(101);
_v_list.push(203);
println!("{:?}", _v_list); // [10, 101, 203]
// 通过索引修改元素
_v_list[0] = 1000;
println!("{:?}", _v_list); // [1000, 101, 203]
// 删除元素
let option = _v_list.pop(); // pop()删除 Vec<T> 最后一个元素
println!("{:?}", option); // Some(203)
println!("{:?}", _v_list); // [1000, 101]
let option = _v_list.remove(1); // remove() 删除 Vec<T> 的指定下标元素
println!("{:?}", option); // 101
println!("{:?}", _v_list); // [1000]
// 访问动态数组
println!("{}", _v_list3[1]); // 通过下标访问
println!("{}", _v_list3[2]);
// 通过点.get()访问
println!("{:?}", _v_list3.get(1)); // Some(2)
// 通过点.get()访问 不会存在下标越界的情况
println!("{:?}", _v_list3.get(10)); // None
// 遍历元素
println!("{:?}", _v_list3); // [1, 2, 3]
for i in _v_list3 {
println!("{}", i); // 1,2,3
}
for i in &mut _v_list2 {
*i += 50;
println!("{}", i);//51,52,53
}
// ② VecDeque<T> 是双端队列 遵从先进先出的原则
let mut vDeque: VecDeque<u32> = VecDeque::new(); // 空双端队列
let mut vDeque: VecDeque<u32> = VecDeque::with_capacity(10); // 容量为10的双端队列
// 添加元素
vDeque.push_front(10); // 向队列前面追加一个元素
vDeque.push_front(20);
vDeque.push_back(100); // 向队列后端追加一个元素
vDeque.push_back(200);
println!("{:?}", vDeque); // [20, 10, 100, 200]
// 修改元素
vDeque[0] = 111; // 通过下标修改
println!("{:?}", vDeque); // [111, 10, 100, 200]
// 删除元素
let option = vDeque.pop_front(); // 删除队列前面元素
println!("{:?}", vDeque); // [10, 100, 200]
let option = vDeque.pop_back(); // 删除队列后面元素
println!("{:?}", vDeque); // [10, 100]
let option = vDeque.remove(1); // 通过索引删除
println!("{:?}", vDeque); // [10]
// 访问
for i in 0..5 {
vDeque.push_front(i);
}
println!("{:?}", vDeque); // [4, 3, 2, 1, 0, 10]
// 下标访问
println!("{}", vDeque[0]);// 4
println!("{}", vDeque[3]);// 1
println!("{}", vDeque[5]);// 10
// .get()访问
println!("{:?}", vDeque.get(6));//None
println!("{:?}", vDeque.get(1));//Some(3)
// ③ HashMap<K,V> 基于哈希算法来存储的键值对
let mut map: HashMap<&str, i32> = HashMap::new(); // 空键值对
let mut map: HashMap<&str, i32> = HashMap::with_capacity(10); // 容量为10的键值对
// 添加 键-值
map.insert("张三", 20);
map.insert("李四", 21);
println!("{:?}", map); // {"张三": 20, "李四": 21}
map.insert("张三", 24); // 插入碰到 key相同的就更新对应的value
println!("{:?}", map); // {"张三": 24, "李四": 21}
// entry 和 or_insert方法来检查是否有对应的值
let option = map.entry("张三"); // entry 检查张三是否存在
map.entry("王五").or_insert(99); // key == 王五 不存在 就插入 王五:99
println!("{:?}", map);//{"李四": 21, "王五": 99, "张三": 24}
map.entry("王五").or_insert(999); // key == 王五 存在 就不插入 王五:99 没变999
println!("{:?}", map);//{"李四": 21, "王五": 99, "张三": 24}
// 修改 元素
// map["张三"] = 100; // 无法分配 所有权问题
// 1. 用insert 碰到相同的就更新
map.insert("张三", 1000);
println!("{:?}", map);// {"李四": 21, "张三": 1000, "王五": 99}
// 2. 通过迭代器更新
for (i, v) in map.iter_mut() {
*v = *v + 10;
println!("{:?}==={:?}", i, v); // k 和 v 都打印出来了
}
println!("{:?}", map);// {"李四": 31, "王五": 109, "张三": 1010}
// 删除元素 remove()
map.remove("李四"); // 删除成功
println!("{:?}", map);// {"张三": 1010, "王五": 109}
map.remove("李四"); // 删除失败 返回 none
println!("{:?}", map);// {"张三": 1010, "王五": 109}
// 访问元素
// 1. 索引
println!("{:?}", map["张三"]); // 1010
// println!("{:?}", map["张三风"]); // 报错 , 不存在 张三丰 系统panic(奔溃)
// 2. .get()
println!("{:?}", map.get("张三")); // Some(1010)
println!("{:?}", map.get("张三风")); // None
}
五，字符串
use std::collections::{HashMap, VecDeque};
fn main() {
// 字符串类型
// 1.固定长度字符串 &str
let str = "刘洋";
let str = String::from("张三").as_str(); // 先定义可变字符串 在转成 &str
// 2.可变长度字符串 String
let str = String::from("111");
let str = String::new(); // 空字符串
let str = "张三".to_string(); // 先定义 固定长度字符串在 转 string
// 字符串的 增删改查 只有 String 类型的有 &str 是固定长的
let mut s = String::new();
// 追加 push push_str
s.push('R'); // 追加 字节的
s.push_str("刘洋"); // 追加 string类型的
println!("{}", s); // R刘洋
// 插入 insert insert_str
s.insert(1, 'D'); // 插入 字节
s.insert_str(1, "舞蹈"); // 插入 字符串
println!("{}", s); // R舞蹈D刘洋
// 链接字符串 + format!
let a1 = String::from("我");
let a2 = String::from("喜");
let a3 = String::from("欢");
let a4 = a1 + &a2 + &a3;
println!("{}", a4);//我喜欢
let a4 = format!("{}-{}", a2, a3); // 这里的a1的所有权 消失了
println!("{}", a4); // 喜-欢
// 替换字符串 replace替换所以 replacen替换次数
let mut l = String::from("aaabbaaaacccbbaaaaaaabb");
let l1 = l.replace("bb", "77");
println!("{}", l1); // aaa77aaaaccc77aaaaaaa77
let l2 = l.replacen("bb", "77", 2);
println!("{}", l2); // aaa77aaaaccc77aaaaaaabb
// 删除字符串
let mut l = String::from("aa张三aa来了aa");
println!("{}", l); //aa张三aa来了aa
// 1. pop 删除最后一个 返回删除元素本身
l.pop();
println!("{}", l); //aa张三aa来了a
// 2. remove 删除指定字符串
l.remove(2);
println!("{}", l); //aa三aa来了a
// 3. truncate 删除指定字符串，指定位置 到 结尾的全部字符串
l.truncate(2);
println!("{}", l); //aa
// 4. clear 等于 清空字符串
l.clear();
println!("{}", l); // ""
// 字符串是以unicode字节集组成 ，最小的单位是 字节 1个汉字3个字节
let mut l = String::from("aa张三aa来了aa");
println!("{}", l.len()); //长度是 18
// 字符串循环
let bytes = l.bytes(); // 处理 字节的
for i in bytes {
println!("{}", i); // 18 97 97 ...
}
let chars = l.chars(); // 处理 utf-8的
for i in chars {
println!("{}", i); // a a 张 三 ...
}
}
六，字面量
fn main() {
println!("1111")
// + - * / %
//> < >= <= == !=
// &&(两边为true，就为true，一个为false就是false) ||（一个为true就是true） !（取反）
// & | ^ ! << >> （完全是懵逼的）
// 设计到 二进制 转码 掩码 补码 啥的 学过一次忘了 反正就很懵逼 也不知道学了干嘛用
// 特别是 << >> 以后在复习吧
}
发表评论