回到：

詳細分析awk字段分割

awk讀取每一條記錄之後，會將其賦值給$0，同時還會對這條記錄按照預定義變量FS劃分字段，將劃分好的各個字段分別賦值給$1 $2 $3 $4...$N，同時將劃分的字段數量賦值給預定義變量NF。

引用字段的方式

$N引用字段：

• N=0：即$0，引用記錄本身
• 0<N<=NF：引用對應字段
• N>NF：表示引用不存在的字段，返回空字符串
• N<0：報錯

可使用變量或計算的方式指定要獲取的字段序號。

awk '{n = 5;print $n}' a.txt
awk '{print $(2+2)}' a.txt   # 括號必不可少，用於改變優先級
awk '{print $(NF-3)}' a.txt

分割字段的方式

讀取record之後，將使用預定義變量FS、FIELDWIDTHS或FPAT中的一種來分割字段。分割完成之後，再進入main代碼段(所以，在main中設置FS對本次已經讀取的record是沒有影響的，但會影響下次讀取)。

劃分字段方式(一)：FS或-F

FS或者-F：字段分隔符

• FS為單個字符時，該字符即為字段分隔符
• FS為多個字符時，則採用正則表達式模式作為字段分隔符
• 特殊的，也是FS默認的情況，FS為單個空格時，將以連續的空白（空格、製表符、換行符）作為字段分隔符
• 特殊的，FS為空字符串””時，將對每個字符都進行分隔，即每個字符都作為一個字段
• 設置預定義變量IGNORECASE為非零值，正則匹配時表示忽略大小寫(隻影響正則，所以FS為單字時無影響)
• 如果record中無法找到FS指定的分隔符(例如將FS設置為”\n”)，則整個記錄作為一個字段，即$1和$0相等

# 字段分隔符指定為單個字符
awk -F":" '{print $1}' /etc/passwd
awk 'BEGIN{FS=":"}{print $1}' /etc/passwd

# 字段分隔符指定為正則表達式
awk 'BEGIN{FS=" +|@"}{print $1,$2,$3,$4,$5,$6}' a.txt

劃分字段方式(二)：FIELDWIDTHS

指定預定義變量FIELDWIDTHS按字符寬度分割字段，這是gawk提供的高級功能。在處理某字段缺失時非常好用。

用法：

示例1：

# 沒取完的字符串DDD被丟棄，且NF=3
$ awk 'BEGIN{FIELDWIDTHS="2 3 2"}{print $1,$2,$3,$4}' <<<"AABBBCCDDDD"
AA BBB CC 

# 字符串不夠長度時無視
$ awk 'BEGIN{FIELDWIDTHS="2 3 2 100"}{print $1,$2,$3,$4"-"}' <<<"AABBBCCDDDD"
AA BBB CC DDDD-

# *號取剩餘所有，NF=3
$ awk 'BEGIN{FIELDWIDTHS="2 3 *"}{print $1,$2,$3}' <<<"AABBBCCDDDD"      
AA BBB CCDDDD

# 字段數多了，則取完字符串即可，NF=2
$ awk 'BEGIN{FIELDWIDTHS="2 30 *"}{print $1,$2,NF}' <<<"AABBBCCDDDD"  
AA BBBCCDDDD 2

示例2：處理某些字段缺失的數據。

如果按照常規的FS進行字段分割，則對於缺失字段的行和沒有缺失字段的行很難統一處理，但使用FIELDWIDTHS則非常方便。

假設a.txt文本內容如下：

ID  name    gender  age  email          phone
1   Bob     male    28   abc@qq.com     18023394012
2   Alice   female  24   def@gmail.com  18084925203
3   Tony    male    21   aaa@163.com    17048792503
4   Kevin   male    21   bbb@189.com    17023929033
5   Alex    male    18                  18185904230
6   Andy    female  22   ddd@139.com    18923902352
7   Jerry   female  25   exdsa@189.com  18785234906
8   Peter   male    20   bax@qq.com     17729348758
9   Steven  female  23   bc@sohu.com    15947893212
10  Bruce   female  27   bcbd@139.com   13942943905

因為email字段有的是空字段，所以直接用FS劃分字段不便處理。可使用FIELDWIDTHS。

# 字段1：4字符
# 字段2：8字符
# 字段3：8字符
# 字段4：2字符
# 字段5：先跳過3字符，再讀13字符，該字段13字符
# 字段6：先跳過2字符，再讀11字符，該字段11字符
awk '
BEGIN{FIELDWIDTHS="4 8 8 2 3:13 2:11"}
NR>1{
    print "<"$1">","<"$2">","<"$3">","<"$4">","<"$5">","<"$6">"
}' a.txt

# 如果email為空，則輸出它
awk '
BEGIN{FIELDWIDTHS="4 8 8 2 3:13 2:11"}
NR>1{
    if($5 ~ /^ +$/){print $0}
}' a.txt

劃分字段方式(三)：FPAT

FS是指定字段分隔符，來取得除分隔符外的部分作為字段。

FPAT是取得匹配的字符部分作為字段。它是gawk提供的一個高級功能。

FPAT根據指定的正則來全局匹配record，然後將所有匹配成功的部分組成$1、$2...，不會修改$0。

• awk 'BEGIN{FPAT="[0-9]+"}{print $3"-"}' a.txt
• 之後再設置FS或FPAT，該變量將失效

FPAT常用於字段中包含了字段分隔符的場景。例如，CSV文件中的一行數據如下：

Robbins,Arnold,"1234 A Pretty Street, NE",MyTown,MyState,12345-6789,USA

其中逗號分隔每個字段，但雙引號包圍的是一個字段整體，即使其中有逗號。

這時使用FPAT來劃分各字段比使用FS要方便的多。

echo 'Robbins,Arnold,"1234 A Pretty Street, NE",MyTown,MyState,12345-6789,USA' |\
awk '
    BEGIN{FPAT="[^,]*|(\"[^\"]*\")"}
    {
        for (i=1;i<NF;i++){
            print "<"$i">"
        }
    }
'

最後，patsplit()函數和FPAT的功能一樣。

檢查字段劃分的方式

有FS、FIELDWIDTHS、FPAT三種獲取字段的方式，可使用PROCINFO數組來確定本次使用何種方式獲得字段。

PROCINFO是一個數組，記錄了awk進程工作時的狀態信息。

如果：

• PROCINFO["FS"]=="FS"，表示使用FS分割獲取字段
• PROCINFO["FPAT"]=="FPAT"，表示使用FPAT匹配獲取字段
• PROCINFO["FIELDWIDTHS"]=="FIELDWIDTHS"，表示使用FIELDWIDTHS分割獲取字段

例如：

if(PROCINFO["FS"]=="FS"){
    ...FS spliting...
} else if(PROCINFO["FPAT"]=="FPAT"){
    ...FPAT spliting...
} else if(PROCINFO["FIELDWIDTHS"]=="FIELDWIDTHS"){
    ...FIELDWIDTHS spliting...
}

本站聲明:網站內容來源於博客園,如有侵權,請聯繫我們,我們將及時處理【其他文章推薦】

※USB CONNECTOR掌控什麼技術要點? 帶您認識其相關發展及效能

※評比前十大台北網頁設計、台北網站設計公司知名案例作品心得分享

※智慧手機時代的來臨，RWD網頁設計已成為網頁設計推薦首選

東京新聞25日報導，豐田汽車（Toyota）計畫在2022年於日本國內開賣新型電動車（EV），其電池將採用充電量可達鋰離子電池2倍的「全固體電池」，將大幅提升EV的續航距離，且僅需數分鐘時間就可充飽電。在EV的研發上，由歐美廠商跑在前頭，而豐田期望藉由導入革新性技術扳回劣勢。

報導指出，現行市售的EV所搭載的電池以鋰離子電池為主，不過其弱點在於充飽一次電所能行駛的距離約300-400km、遜於汽油車，且即便使用快速充電技術、也需花費數十分鐘才能充飽電，而採用全固體電池的話，就有望一口氣將上述弱點全數解決。

據報導，全固體電池是將電解質從液體變更為固體，而豐田長年來持續進行全固體電池的研發，並於去年宣佈已攜手東京工業大學成功發現可適用於電解質的固體材料，並將在今年開始進行量產研發。

德國BMW、福斯（Volkswagen）等車廠也正研發全固體電池，不過量產相關計畫仍未明。

日經新聞曾於2011年10月報導，豐田汽車已和東京工業大學及高能源加速器研究機構攜手研發出一款使用新化合物的次世代電動車（EV）用「全固體電池」，其充飽一次電所能行駛的距離最長有望達1,000km左右的水準。

富士經濟6月22日公布調查報告指出，預估2030年時EV年銷售量將增至407萬台、超越油電混合車（HV、2030年銷售量預估為391萬台），且之後雙方的差距將持續擴大。富士經濟預估，在中國需求增加加持下，2035年EV全球銷售量將擴大至630萬台、將達2016年的13.4倍（較2016年增加12.4倍）。

（本文內容由授權使用。圖片出處：Toyota）

本站聲明:網站內容來源於EnergyTrend https://www.energytrend.com.tw/ev/,如有侵權,請聯繫我們,我們將及時處理

【其他文章推薦】

※USB CONNECTOR掌控什麼技術要點? 帶您認識其相關發展及效能

※評比前十大台北網頁設計、台北網站設計公司知名案例作品心得分享

※智慧手機時代的來臨，RWD網頁設計已成為網頁設計推薦首選

這裏來對Java中的String對象做一個稍微深入的了解。

Java對象實現的演進

String對象是Java中使用最頻繁的對象之一，所以Java開發者們也在不斷地對String對象的實現進行優化，以便提升String對象的性能。

Java6以及之前版本中String對象的屬性

在Java6以及之前版本中，String對象是對char數組進行了封裝實現的對象，其主要有4個成員成員變量，分別是char數組、偏移量offset、字符數量count和哈希值hash。String對象是通過offset和count兩個屬性來定位char[]數組，獲取字符串。這樣做可以高效、快速地共享數組對象，同時節省內存空間，但是這種方式卻可能會導致內存泄漏的發生。

Java7、8版本中String對象的屬性

從Java7版本開始，Java對String類做了一些改變，具體是String類不再有offset和count兩個變量了。這樣做的好處是String對象佔用的內存稍微少了點，同時String.substring()方法也不再共享char[]了，從而解決了使用該方法可能導致的內存泄漏問題。

Java9以及之後版本中String對象的屬性

從Java9版本開始，Java將char[]數組改為了byte[]數組。我們都知道，char是兩個字節的，如果用來存一個字節的情況下就會造成內存空間的浪費。而為了節約這一個字節的空間，Java開發者就改成了一個使用一個字節的byte來存儲字符串。

另外，在Java9中，String對象維護了一個新的屬性coder，這個屬性是編碼格式的標識，在計算字符串長度或者調用indexOf()方法的時候，會需要根據這個字段去判斷如何計算字符串長度。coder屬性默認有0和1兩個值，其中0代表Latin-1（單字節編碼），1則表示UTF-16編碼。

String對象的創建方式與在內存中的存放

在Java中，對於基本數據類型的變量和對對象的引用，保存在棧內存的局部變量表中；而通過new關鍵字和Constructor創建的對象，則是保存在堆內存中。而String對象的創建方式一般為兩種，一種是字面量（字符串常量）的方式，一種則是構造函數（String()）的方式，兩種方式在內存中的存放有所不同。

字面量（字符串常量）的創建方式

使用字面量的方式創建字符串時，JVM會在字符串常量池中先檢查是否存在該字面量，如果存在，則返回該字面量在內存中的引用地址；如果不存在，則在字符串常量池中創建該字面量並返回引用。使用這種方式創建的好處是避免了相同值的字符串在內存中被重複創建，節約了內存，同時這種寫法也會比較簡單易讀一些。

String str = "i like yanggb.";

字符串常量池

這裏要特別說明一下常量池。常量池是JVM為了減少字符串對象的重複創建，特別維護了一個特殊的內存，這段內存被稱為字符串常量池或者字符串字面量池。在JDK1.6以及之前的版本中，運行時常量池是在方法區中的。在JDK1.7以及之後版本的JVM，已經將運行時常量池從方法區中移了出來，在Java堆（Heap）中開闢了一塊區域用來存放運行時常量池。而從JDK1.8開始，JVM取消了Java方法區，取而代之的是位於直接內存的元空間（MetaSpace）。總結就是，目前的字符串常量池在堆中。

我們所知道的幾個String對象的特點都來源於String常量池。

1.在常量池中會共享所有的String對象，因此String對象是不可被修改的，因為一旦被修改，就會導致所有引用此String對象的變量都隨之改變（引用改變），所以String對象是被設計為不可修改的，後面會對這個不可變的特性做一個深入的了解。

2.String對象拼接字符串的性能較差的說法也是來源於此，因為String對象不可變的特性，每次修改（這裡是拼接）都是返回一個新的字符串對象，而不是再原有的字符串對象上做修改，因此創建新的String對象會消耗較多的性能（開闢另外的內存空間）。

3.因為常量池中創建的String對象是共享的，因此使用雙引號聲明的String對象（字面量）會直接存儲在常量池中，如果該字面量在之前已存在，則是會直接引用已存在的String對象，這一點在上面已經描述過了，這裏再次提及，是為了特別說明這一做法保證了在常量池中的每個String對象都是唯一的，也就達到了節約內存的目的。

構造函數（String()）的創建方式

使用構造函數的方式創建字符串時，JVM同樣會在字符串常量池中先檢查是否存在該字面量，只是檢查后的情況會和使用字面量創建的方式有所不同。如果存在，則會在堆中另外創建一個String對象，然後在這個String對象的內部引用該字面量，最後返回該String對象在內存地址中的引用；如果不存在，則會先在字符串常量池中創建該字面量，然後再在堆中創建一個String對象，然後再在這個String對象的內部引用該字面量，最後返回該String對象的引用。

String str = new String("i like yanggb.");

這就意味着，只要使用這種方式，構造函數都會另行在堆內存中開闢空間，創建一個新的String對象。具體的理解是，在字符串常量池中不存在對應的字面量的情況下，new String()會創建兩個對象，一個放入常量池中（字面量），一個放入堆內存中（字符串對象）。

String對象的比較

比較兩個String對象是否相等，通常是有【==】和【equals()】兩個方法。

在基本數據類型中，只可以使用【==】，也就是比較他們的值是否相同；而對於對象（包括String）來說，【==】比較的是地址是否相同，【equals()】才是比較他們內容是否相同；而equals()是Object都擁有的一個函數，本身就要求對內部值進行比較。

String str = "i like yanggb.";
String str1 = new String("i like yanggb.");

System.out.println(str == str1); // false
System.out.println(str.equals(str1)); // true

因為使用字面量方式創建的String對象和使用構造函數方式創建的String對象的內存地址是不同的，但是其中的內容卻是相同的，也就導致了上面的結果。

String對象中的intern()方法

我們都知道，String對象中有很多實用的方法。為什麼其他的方法都不說，這裏要特別說明這個intern()方法呢，因為其中的這個intern()方法最為特殊。它的特殊性在於，這個方法在業務場景中幾乎用不上，它的存在就是在為難程序員的，也可以說是為了幫助程序員了解JVM的內存結構而存在的（？我信你個鬼，你個糟老頭子壞得很）。

/**
* When the intern method is invoked, if the pool already contains a
* string equal to this {@code String} object as determined by
* the {@link #equals(Object)} method, then the string from the pool is
* returned. Otherwise, this {@code String} object is added to the
* pool and a reference to this {@code String} object is returned.
**/
public native String intern();

上面是源碼中的intern()方法的官方註釋說明，大概意思就是intern()方法用來返回常量池中的某字符串，如果常量池中已經存在該字符串，則直接返回常量池中該對象的引用。否則，在常量池中加入該對象，然後返回引用。然後我們可以從方法簽名上看出intern()方法是一個native方法。

下面通過幾個例子來詳細了解下intern()方法的用法。

第一個例子

String str1 = new String("1");
System.out.println(str1 == str1.intern()); // false
System.out.println(str1 == "1"); // false

在上面的例子中，intern()方法返回的是常量池中的引用，而str1保存的是堆中對象的引用，因此兩個打印語句的結果都是false。

第二個例子

String str2 = new String("2") + new String("3");
System.out.println(str2 == str2.intern()); // true
System.out.println(str2 == "23"); // true

在上面的例子中，str2保存的是堆中一個String對象的引用，這和JVM對【+】的優化有關。實際上，在給str2賦值的第一條語句中，創建了3個對象，分別是在字符串常量池中創建的2和3、還有在堆中創建的字符串對象23。因為字符串常量池中不存在字符串對象23，所以這裏要特別注意：intern()方法在將堆中存在的字符串對象加入常量池的時候採取了一種截然不同的處理方案——不是在常量池中建立字面量，而是直接將該String對象自身的引用複製到常量池中，即常量池中保存的是堆中已存在的字符串對象的引用。根據前面的說法，這時候調用intern()方法，就會在字符串常量池中複製出一個對堆中已存在的字符串常量的引用，然後返回對字符串常量池中這個對堆中已存在的字符串常量池的引用的引用（就是那麼繞，你來咬我呀）。這樣，在調用intern()方法結束之後，返回結果的就是對堆中該String對象的引用，這時候使用【==】去比較，返回的結果就是true了。同樣的，常量池中的字面量23也不是真正意義的字面量23了，它真正的身份是堆中的那個String對象23。這樣的話，使用【==】去比較字面量23和str2，結果也就是true了。

第三個例子

String str4 = "45";
String str3 = new String("4") + new String("5");
System.out.println(str3 == str3.intern()); // false
System.out.println(str3 == "45"); // false

這個例子乍然看起來好像比前面的例子還要複雜，實際上卻和上面的第一個例子是一樣的，最難理解的反而是第二個例子。

所以這裏就不多說了，而至於為什麼還要舉這個例子，我相信聰明的你一下子就明白了（我有醫保，你來打我呀）。

String對象的不可變性

先來看String對象的一段源碼。

public final class String
    implements java.io.Serializable, Comparable<String>, CharSequence {
    /** The value is used for character storage. */
    private final char value[];

    /** Cache the hash code for the string */
    private int hash; // Default to 0

    /** use serialVersionUID from JDK 1.0.2 for interoperability */
    private static final long serialVersionUID = -6849794470754667710L;
}

從類簽名上來看，String類用了final修飾符，這就意味着這個類是不能被繼承的，這是決定String對象不可變特性的第一點。從類中的數組char[] value來看，這個類成員變量被private和final修飾符修飾，這就意味着其數值一旦被初始化之後就不能再被更改了，這是決定String對象不可變特性的第二點。

Java開發者為什麼要將String對象設置為不可變的，主要可以從以下三個方面去考慮：

1.安全性。假設String對象是可變的，那麼String對象將可能被惡意修改。

2.唯一性。這個做法可以保證hash屬性值不會頻繁變更，也就確保了唯一性，使得類似HashMap的容器才能實現相應的key-value緩存功能。

3.功能性。可以實現字符串常量池（究竟是先有設計，還是先有實現呢）。

String對象的優化

字符串是常用的Java類型之一，所以對字符串的操作是避免不了的。而在對字符串的操作過程中，如果使用不當的話，性能可能會有天差地別，所以有一些地方是要注意一下的。

拼接字符串的性能優化

字符串的拼接是對字符串的操作中最頻繁的一個使用。由於我們都知道了String對象的不可變性，所以我們在開發過程中要盡量減少使用【+】進行字符串拼接操作。這是因為使用【+】進行字符串拼接，會在得到最終想要的結果前產生很多無用的對象。

String str = 'i';
str = str + ' ';
str = str + 'like';
str = str + ' ';
str = str + 'yanggb';
str = str + '.';

System.out.println(str); // i like yanggb.

事實上，如果我們使用的是比較智能的IDE編寫代碼的話，編譯器是會提示將代碼優化成使用StringBuilder或者StringBuffer對象來優化字符串的拼接性能的，因為StringBuilder和StringBuffer都是可變對象，也就避免了過程中產生無用的對象了。而這兩種替代方案的區別是，在需要線程安全的情況下，選用StringBuffer對象，這個對象是支持線程安全的；而在不需要線程安全的情況下，選用StringBuilder對象，因為StringBuilder對象的性能在這種場景下，要比StringBuffer對象或String對象要好得多。

使用intern()方法優化內存佔用

前面吐槽了intern()方法在實際開發中沒什麼用，這裏又來說使用intern()方法來優化內存佔用了，這人真的是，嘿嘿，真香。關於方法的使用就不說了，上面有詳盡的用法說明，這裏來說說具體的應用場景好了。有一位Twitter的工程師在Qcon全球軟件開發大會上分享了一個他們對String對象優化的案例，他們利用了這個String.intern()方法將以前需要20G內存存儲優化到只需要幾百兆內存。具體就是，使用intern()方法將原本需要創建到堆內存中的String對象都放到常量池中，因為常量池的不重複特性（存在則返回引用），也就避免了大量的重複String對象造成的內存浪費問題。

什麼，要我給intern()方法道歉？不可能。String.intern()方法雖好，但是也是需要結合場景來使用的，並不能夠亂用。因為實際上，常量池的實現是類似於一個HashTable的實現方式，而HashTable存儲的數據越大，遍歷的時間複雜度就會增加。這就意味着，如果數據過大的話，整個字符串常量池的負擔就會大大增加，有可能性能不會得到提升卻反而有所下降。

字符串分割的性能優化

字符串的分割是字符串操作的常用操作之一，對於字符串的分割，大部分人使用的都是split()方法，split()方法在大部分場景下接收的參數都是正則表達式，這種分割方式本身沒有什麼問題，但是由於正則表達式的性能是非常不穩定的，使用不恰當的話可能會引起回溯問題並導致CPU的佔用居高不下。在以下兩種情況下split()方法不會使用正則表達式：

1.傳入的參數長度為1，且不包含“.$|()[{^?*+\”regex元字符的情況下，不會使用正則表達式。

2.傳入的參數長度為2，第一個字符是反斜杠，並且第二個字符不是ASCII数字或ASCII字母的情況下，不會使用正則表達式。

所以我們在字符串分割時，應該慎重使用split()方法，而首先考慮使用String.indexOf()方法來進行字符串分割，在String.indexOf()無法滿足分割要求的時候再使用Split()方法。而在使用split()方法分割字符串時，需要格外注意回溯問題。

總結

雖然說在不了解String對象的情況下也能使用String對象進行開發，但是了解String對象可以幫助我們寫出更好的代碼。

“只希望在故事的最後，我還是我，你也還是你。”

本站聲明:網站內容來源於博客園,如有侵權,請聯繫我們,我們將及時處理【其他文章推薦】

※USB CONNECTOR掌控什麼技術要點? 帶您認識其相關發展及效能

※評比前十大台北網頁設計、台北網站設計公司知名案例作品心得分享

※智慧手機時代的來臨，RWD網頁設計已成為網頁設計推薦首選