Rust 집합 과 문자열

Rust 집합 과 문자열
집합 (Collection) 은 데이터 구조 에서 가장 보편적 인 데이터 저장 형식 으로 Rust 표준 라 이브 러 리 에서 풍부 한 집합 유형 을 제공 하여 개발 자가 데이터 구 조 를 처리 하 는 데 도움 을 주 었 다.
벡터
벡터 (Vector) 는 다 중 값 을 저장 하 는 단일 데이터 구조 로 이 구 조 는 같은 유형의 값 을 메모리 에 선형 으로 저장 합 니 다.
벡터 는 선형 표 이 고 Rust 에서 Vec 를 나타 낸다.
벡터 의 사용 방식 은 목록 (List) 과 유사 합 니 다. 우 리 는 이러한 방식 으로 지정 한 형식의 벡터 를 만 들 수 있 습 니 다.

let vector: Vec = Vec::new(); //       i32     
let vector = vec![1, 2, 4, 8];     //

우 리 는 선형 표를 사용 할 때 항상 추가 적 인 조작 을 사용 하지만 스 택 의 push 작업 본질 과 같 기 때문에 벡터 는 push 방법 만 하나의 요 소 를 추가 합 니 다.
실례
fn main
(
)
{

let
mut vector
= vec
!
[
1
,
2
,
4
,
8
]
;
vector.push
(
16
)
;
vector.push
(
32
)
;
vector.push
(
64
)
;
println
!
(
"{:?}"
, vector
)
;
}
실행 결과:

[1, 2, 4, 8, 16, 32, 64]

append 방법 은 벡터 를 다른 벡터 의 끝 에 연결 하 는 데 사 용 됩 니 다.
실례
fn main
(
)
{

let
mut v1
: Vec
>
= vec
!
[
1
,
2
,
4
,
8
]
;

let
mut v2
: Vec
>
= vec
!
[
16
,
32
,
64
]
;
v1.append
(
&
mut v2
)
;
println
!
(
"{:?}"
, v1
)
;
}
실행 결과:

[1, 2, 4, 8, 16, 32, 64]

get 방법 은 벡터 의 값 을 추출 하 는 데 사 용 됩 니 다:
실례
fn main
(
)
{

let
mut v
= vec
!
[
1
,
2
,
4
,
8
]
;
println
!
(
"{}"
,
match v.get
(
0
)
{
Some
(value
)
=> value.to_string
(
)
,
None
=>
"None".to_string
(
)

}
)
;
}
실행 결과:

벡터 의 길 이 는 논리 적 으로 추정 할 수 없 기 때문에 get 방법 은 일정한 값 을 얻 을 수 없 기 때문에 get 방법의 반환 값 은 Option 매 거 진 클래스 로 비어 있 을 수 있 습 니 다.
이것 은 안전 한 수치 채취 방법 이지 만, 쓰기 에는 좀 번거롭다.만약 당신 이 값 을 추출 하 는 아래 표 시 는 벡터 아래 표 시 된 값 범 위 를 초과 하지 않 을 것 이 라 고 보장 할 수 있다 면, 당신 도 배열 의 값 을 추출 하 는 문법 을 사용 할 수 있 습 니 다.
실례
fn main
(
)
{

let v
= vec
!
[
1
,
2
,
4
,
8
]
;
println
!
(
"{}"
, v
[
1
]
)
;
}
실행 결과:

그러나 우리 가 v [4] 를 가 져 오 려 고 시도 하면 벡터 는 오 류 를 되 돌려 줍 니 다.
반복 벡터:
실례
fn main
(
)
{

let v
= vec
!
[
100
,
32
,
57
]
;

for i
in
&v
{
println
!
(
"{}"
, i
)
;

}
}
실행 결과:

100
32
57

옮 겨 다 니 는 과정 에서 변수의 값 을 변경 해 야 한다 면:
실례
fn main
(
)
{

let
mut v
= vec
!
[
100
,
32
,
57
]
;

for i
in
&
mut v
{

*i
+=
50
;

}
}
문자열
문자열 클래스 (String) 는 이 장 까지 많이 사용 되 었 기 때문에 독자 들 에 게 잘 알려 진 방법 이 많 습 니 다.이 장 에 서 는 문자열 의 방법 과 UTF - 8 의 성질 을 소개 한다.
새 문자열:

let string = String::new();

기본 형식 을 문자열 로 변환:

let one = 1.to_string();         //       
let float = 1.3.to_string();     //        
let slice = "slice".to_string(); //

UTF - 8 문 자 를 포함 하 는 문자열:

let hello = String::from("السلام عليكم");
let hello = String::from("Dobrý den");
let hello = String::from("Hello");
let hello = String::from("שָׁלוֹם");
let hello = String::from("नमस्ते");
let hello = String::from("こんにちは");
let hello = String::from("안녕하세요");
let hello = String::from("  ");
let hello = String::from("Olá");
let hello = String::from("Здравствуйте");
let hello = String::from("Hola");

문자열 추가:

let mut s = String::from("run");
s.push_str("oob"); //        
s.push('!');       //

+ 번호 로 문자열 맞 추기:

let s1 = String::from("Hello, ");
let s2 = String::from("world!");
let s3 = s1 + &s2;

이 문법 은 문자열 절편 도 포함 할 수 있 습 니 다.

let s1 = String::from("tic");
let s2 = String::from("tac");
let s3 = String::from("toe");

let s = s1 + “-” + &s2 + “-” + &s3;
format 사용!매크로:

let s1 = String::from("tic");
let s2 = String::from("tac");
let s3 = String::from("toe");

let s = format!("{}-{}-{}", s1, s2, s3);
문자열 길이:

let s = "hello";
let len = s.len();

여기 len 의 값 은 5 입 니 다.

let s = "  ";
let len = s.len();

여기 렌 의 값 은 6 이다.중국 어 는 UTF - 8 인 코딩 으로 문자 당 3 바이트 가 길 기 때문에 길이 가 6 입 니 다.그러나 Rust 에 서 는 UTF - 8 문자 대상 을 지원 하기 때문에 문자 수 를 집계 하려 면 문자열 을 문자 집합 으로 선택 할 수 있 습 니 다.

let s = "hello  ";
let len = s.chars().count();

여기 len 의 값 은 7 입 니 다. 모두 7 글자 가 있 기 때 문 입 니 다.통계 문자 의 속 도 는 통계 데이터 의 길이 보다 훨씬 느리다.
문자열 옮 겨 다 니 기:
실례
fn main
(
)
{

let s
= String
::
from
(
"hello 중국어"
)
;

for c
in s.chars
(
)
{
println
!
(
"{}"
, c
)
;

}
}
실행 결과:

h
e
l
l
o

문자열 에서 단일 문자 가 져 오기:
실례
fn main
(
)
{

let s
= String
::
from
(
"EN 중국어".
)
;

let a
= s.chars
(
).nth
(
2
)
;
println
!
(
"{:?}"
, a
)
;
}
실행 결과:

Some(' ')

주의: nth 함 수 는 교체 기 에서 어떤 값 을 꺼 내 는 방법 입 니 다. 옮 겨 다 니 면서 이렇게 사용 하지 마 십시오!UTF - 8 문자 마다 길이 가 같 지 않 기 때 문 입 니 다!문자열 문자열 을 캡 처 하려 면:
실례
fn main
(
)
{

let s
= String
::
from
(
"EN 중국어".
)
;

let sub
=
&s
[
0..
2
]
;
println
!
(
"{}"
, sub
)
;
}
실행 결과:

EN

하지만 이 용법 은 UTF - 8 문 자 를 분해 할 수 있 음 을 주의 하 세 요!그러면 잘못 보고 할 수 있다.
실례
fn main
(
)
{

let s
= String
::
from
(
"EN 중국어".
)
;

let sub
=
&s
[
0..
3
]
;
println
!
(
"{}"
, sub
)
;
}
실행 결과:

thread 'main' panicked at 'byte index 3 is not a char boundary; it is inside ' ' (bytes 2..5) of `EN  `', src\libcore\str\mod.rs:2069:5 
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace.

매 핑 테이블
맵 (Map) 은 다른 언어 에서 광범 위 하 게 존재 한다.그 중에서 가장 보편적으로 사용 되 는 것 은 키 해시 맵 (Hash Map) 이다.
해시 값 맵 을 새로 만 듭 니 다:
실례
use std
::
collections
::
HashMap
;
fn main
(
)
{

let
mut map
=
HashMap
::
new
(
)
;
map.insert
(
"color"
,
"red"
)
;
map.insert
(
"size"
,
"10 m^2"
)
;
println
!
(
"{}"
, map.get
(
"color"
).unwrap
(
)
)
;
}
메모: 산 목록 의 범 형 을 설명 하지 않 은 것 은 Rust 의 자동 판단 유형 체제 때 문 입 니 다.
실행 결과:

red

insert 방법 과 get 방법 은 맵 표 에서 가장 자주 사용 하 는 두 가지 방법 입 니 다.
맵 테이블 지원 교체 기:
실례
use std
::
collections
::
HashMap
;
fn main
(
)
{

let
mut map
=
HashMap
::
new
(
)
;
map.insert
(
"color"
,
"red"
)
;
map.insert
(
"size"
,
"10 m^2"
)
;

for p
in map.iter
(
)
{
println
!
(
"{:?}"
, p
)
;

}
}
실행 결과:

("color", "red") 
("size", "10 m^2")

교체 요 소 는 키 값 이 맞 음 을 나타 내 는 원 그룹 입 니 다.
Rust 의 맵 표 는 매우 편리 한 데이터 구조 입 니 다. insert 방법 으로 새로운 키 값 을 추가 할 때 같은 키 가 존재 하면 해당 하 는 값 을 직접 덮어 씁 니 다.'안전하게 삽입' 하려 면 현재 키 가 존재 하지 않 는 지 확인 할 때 실행 하 는 삽입 동작 입 니 다. 이렇게 할 수 있 습 니 다.

map.entry("color").or_insert("red");

이 말 은 'color' 키 가 없 으 면 'red' 키 를 추가 하고 'red' 로 설정 하지 않 으 면 건 너 간 다 는 뜻 이다.
어떤 키 가 확 정 된 상태 에서 해당 하 는 값 을 직접 수정 하려 면 더 빠 른 방법 이 있 습 니 다.
실례
use std
::
collections
::
HashMap
;
fn main
(
)
{

let
mut map
=
HashMap
::
new
(
)
;
map.insert
(
1
,
"a"
)
;

if
let Some
(x
)
= map.get_mut
(
&
1
)
{

*x
=
"b"
;

}
}

Rust 집합 과 문자열

좋은 웹페이지 즐겨찾기