別和「曾深愛過的人」復合 專家歸納「這3個原因」:破鏡自古難重園!

每個人都懷著各自的故事,把對一個人的愛恨情仇都藏在心裡,不動聲色地過著日子。

在失去中慢慢懂得原諒,也在釋懷中學著成長。

但就是無法忘記。忘記一個曾經心愛過的人究竟有多難呢?

至少,比當初愛上他要難得多。或許,一直就沒有忘記過吧。

相信那些經歷過失戀的人,都有這樣的體驗,雖然已經分手了,卻常常會想起前任,有時候還會忍不住崩潰的大哭。

有的人,雖然已經分手了好幾年,甚至期間從來未有過聯繫,

但還是始終放不下那個人,也沒辦法好好的談一段新的戀愛,

對愛情充滿了恐懼,彷彿這輩子非TA不可的感覺,十分痛苦與煎熬。

有的人與前任一直分分合合,每次以為會重新開始,卻又因為各種原因再次分開,反覆如此弄得雙方的筋疲力盡。

為什麼你這麼努力的讓自己不想起他,

卻始終被他的影子所折磨,放不下、走不出去呢?

如果你正面臨著這些困擾,如果你正在糾結要不要和曾經深愛過的TA複合?

 不妨看看這篇文章吧,或許對你有所啟發。

一、一定要理性地評估你們之間的關係

對於那些經歷過分分合合的人來說,這些折磨的經歷讓他們痛苦不堪,

或者是對於那些當初“被分手”的那一方,始終念著前任的好,放不下那段感情。對於這種情況,

作為一名諮詢師,我建議你,一定要學會理性的去評估你們之間複合的可能性,首先,問自己兩個問題。

問題一:既然曾經深深愛過,當初為什麼分手?如果是因為一些客觀條件,比如異地的話,你們現在是否已經克服了這個困難。如果因為性格不合,經常吵架鬧矛盾的話,要知道人格特質是一種比較穩定的特徵,是難以改變的。所以,如果你們一直沒有找到良好的相處模式,即便是再次複合,時間久了之後也會出現相同的問題。

問題二:到底是放不下前任曾經對你的好,還是其他什麼?若是你懷念那種親密的感受,要知道這種感覺並不針對某個特定的人。與其去懷念失去的東西,不如著眼於當下和未來,以新的心態去迎接未來會建立起的新的親密關係。

 那麼,分手過後,如何走出困境呢?

二、積極尋求支持-

對於剛剛失戀的人來說,由於剛從一段極其親密的關係中走出,會感到一些不適應。

因為愛情會給我們帶來親密感,我們以前的心裡話、感受都能夠向對方傾訴,

而分手之後,一時半會找不到可以傾訴的人,所以會覺得失落、難過。

此時,不妨試著重新聯繫那些曾經的朋友,和他們一起聊天、外出遊玩、逛街。

這樣不僅能轉移你的注意力,避免你一直把自己沉浸在那種痛苦中,也能幫助你打開自己封閉的內心,去將自己的感受向朋友吐露。

慢慢的,當你建立起新的社會支持之後,你就會感到,即使沒有了那個人,你也能感受到身邊人的關心與支持,建立起親密的關係。

三、學會重新獲得對自己生活的掌控感-突然的變故會讓我們手足無措,感到難以接受,難以適應。當你失戀之後,不要總是告訴自己一定要儘早忘記那個人,因為你越去想這個事,注意力就會越集中在這件事上面。不妨把重心投入你自己的生活中,去追求你喜歡的事業,去關心你的家人、朋友。要知道你完全有能力過好你自己的生活,能夠掌握好你生活的節奏。

參考來源:Toutiao

本站聲明:網站內容來源http://www.look543.com,如有侵權,請聯繫我們,我們將及時處理

電子菸
電子煙
電子菸

你知道和你不知道的冒泡排序

這篇文章包含了你一定知道的,和你不一定知道的冒泡排序。

gif看不了可以點擊【原文】查看gif。

1. 什麼是冒泡排序

可能對於大多數的人來說比如我,接觸的第一個算法就是冒泡排序。

我看過的很多的文章都把冒泡排序描述成我們喝的汽水,底部不停的有二氧化碳的氣泡往上冒,還有描述成魚吐泡泡,都特別的形象。

其實結合一杯水來對比很好理解,將我們的數組豎著放進杯子,數組中值小的元素密度相對較小,值大的元素密度相對較大。這樣一來,密度大的元素就會沉入杯底,而密度小的元素會慢慢的浮到杯子的最頂部,稍微專業一點描述如下。

冒泡算法會運行多輪,每一輪會依次比較數組中相鄰的兩個元素的大小,如果左邊的元素大於右邊的元素,則交換兩個元素的位置。最終經過多輪的排序,數組最終成為有序數組。

2. 排序過程展示

我們先不聊空間複雜度和時間複雜度的概念,我們先通過一張動圖來了解一下冒泡排序的過程。

這個圖形象的還原了密度不同的元素上浮和下沉的過程。

3. 算法V1

3.1 代碼實現

private void bubbleSort(int[] arr) {
  for (int i = 0; i < arr.length; i++) {
    for (int j = 0; j < arr.length - 1; j++) {
      if (arr[j] > arr[j + 1]) {
        exchange(arr, j, j + 1);
      }
    }
  }
}

private void exchange(int arr[], int i, int j) {
  int temp = arr[i];
  arr[i] = arr[j];
  arr[j] = temp;
}

int[] arr = new int[]{5, 1, 3, 7, 6, 2, 4};
bubbleSort(arr);
System.out.println(Arrays.toString(arr)); // [1, 2, 3, 4, 5, 6, 7]

3.2 實現分析

各位大佬看了上面的代碼之後先別激動,坐下坐下,日常操作。可能很多的第一個冒泡排序算法就是這麼寫的,比如我,同時還自我感覺良好,覺得算法也不過如此。

我們還是以數組[5, 1, 3, 7, 6, 2, 4]為例,我們通過動圖來看一下過程。

思路很簡單,我們用兩層循環來實現冒泡排序。

  • 第一層,控制冒泡排序總共執行的輪數,例如例子數組的長度是7,那麼總共需要執行6輪。如果長度是n,則需要執行n-1輪
  • 第二層,負責從左到右依次的兩兩比較相鄰元素,並且將大的元素交換到右側

這就是冒泡排序V1的思路。

下錶是通過對一個0-100000的亂序數組的標準樣本,使用V1算法進行排序所總共執行的次數,以及對同一個數組執行100次V1算法的所花的平均時間。

算法執行情況 結果
樣本 [0 – 100000] 的亂序數組
算法 V1 執行的總次數 99990000 次(9999萬次
算法 V1 運行 100 次的平均時間 181 ms

4. 算法V2

4.1 實現分析

仔細看動圖我們可以發現,每一輪的排序,都從數組的最左端再到最右。而每一輪的冒泡,都可以確定一個最大的數,固定在數組的最右邊,也就是密度最大的元素會冒泡到杯子的最上面。

還是拿上面的數組舉例子。下圖是第一輪冒泡之後數組的元素位置。

第二輪排序之後如下。

可以看到,每一輪排序都會確認一個最大元素,放在數組的最後面,當算法進行到後面,我們根本就沒有必要再去比較數組後面已經有序的片段,我們接下來針對這個點來優化一下。

4.2 代碼實現

這是優化之後的代碼。

private void bubbleSort(int[] arr) {
  for (int i = 0; i < arr.length - 1; i++) {
    for (int j = 0; j < arr.length - 1 - i; j++) {
      if (arr[j] > arr[j + 1]) {
        exchange(arr, j, j + 1);
      }
    }
  }
}

private void exchange(int arr[], int i, int j) {
  int temp = arr[i];
  arr[i] = arr[j];
  arr[j] = temp;
}

int[] arr = new int[]{5, 1, 3, 7, 6, 2, 4};
bubbleSort(arr);
System.out.println(Arrays.toString(arr)); // [1, 2, 3, 4, 5, 6, 7]

優化之後的實現,也就變成了我們動圖中所展示的過程。

每一步之後都會確定一個元素在數組中的位置,所以之後的每次冒泡的需要比較的元素個數就會相應的減1。這樣一來,避免了去比較已經有序的數組,從而減少了大量的時間。

算法執行情況 結果
樣本 [0 – 10000] 的亂序數組
算法 V2 執行的總次數 49995000 次(4999萬次
算法 V2 運行 100 次的平均時間 144 ms
運行時間與 V1 對比 V2 運行時間減少 20.44 %
執行次數與 V1 對比 V2 運行次數減少 50.00 %

可能會有人看到,時間大部分已經會覺得滿足了。從數據上看,執行的次數減少了50%,而運行的時間也減少了20%,在性能上已經是很大的提升了。而且已經減少了7億次的執行次數,已經很NB了。 那是不是到這就已經很完美了呢?

答案是No

4.3 哪裡可以優化

同理,我們還是拿上面長度為7的數組來舉例子,只不過元素的位置有所不同,假設數組的元素如下。

[7, 1, 2, 3, 4, 5, 6]

我們再來一步一步的執行V2算法, 看看會發生什麼。

第一步執行完畢后,數組的情況如下。

繼續推進,當第一輪執行完畢后,數組的元素位置如下。

這個時候,數組已經排序完畢,但是按照目前的V2邏輯,仍然有5輪排序需要繼續,而且程序會完整的執行完5輪的排序,如果是100000輪呢?這樣將會浪費大量的計算資源。

5. 算法V3

5.1 代碼實現

private void bubbleSort(int[] arr) {
  for (int i = 0; i < arr.length - 1; i++) {
    boolean flag = true;
    for (int j = 0; j < arr.length - 1 - i; j++) {
      if (arr[j] > arr[j + 1]) {
        flag = false;
        exchange(arr, j, j + 1);
      }
    }
    if (flag) {
      break;
    }
  }
}

private void exchange(int arr[], int i, int j) {
  int temp = arr[i];
  arr[i] = arr[j];
  arr[j] = temp;
}

int[] arr = new int[]{5, 1, 3, 7, 6, 2, 4};
bubbleSort(arr);
System.out.println(Arrays.toString(arr)); // [1, 2, 3, 4, 5, 6, 7]

5.2 實現分析

我們在V2代碼的基礎上,在第一層循環,也就是控制總冒泡輪數的循環中,加入了一個標誌為flag。用來標示該輪冒泡排序中,數組是否是有序的。每一輪的初始值都是true。

當第二層循環,也就是冒泡排序的元素兩兩比較完成之後,flag的值仍然是true,則說明在這輪比較中沒有任何元素被交換了位置。也就是說,數組此時已經是有序狀態了,沒有必要再執行後續的剩餘輪數的冒泡了。

所以,如果flag的值是true,就直接break了(沒有其他的操作return也沒毛病)。

算法執行情況 結果
樣本 [0 – 10000] 的亂序數組
算法 V3 執行的總次數 49993775
算法 V3 運行 100 次的平均時間 142 ms
運行時間與 V2 對比 V3 運行時間減少 00.00 %
執行次數與 V2 對比 V3 運行次數減少 00.00 %

5.3 數據分析

大家看到數據可能有點懵逼。

你這個優化之後,運行時間執行次數都沒有減少。你這優化的什麼東西?

其實,這就要說到算法的適用性了。V3的優化是針對原始數據中存在一部分或者大量的數據已經是有序的情況,V3的算法對於這樣的樣本數據才最適用。

其實是我們還沒有到優化這種情況的那一步,但是其實仍然有這樣的說法,面對不同的數據結構,幾乎沒有算法是萬能的

而目前的樣本數據仍然是隨機的亂序數組,所以並不能發揮優化之後的算法的威力。所謂對症下藥,同理並不是所有的算法都是萬能的。對於不同的數據我們需要選擇不同的算法。例如我們選擇[9999,1,2,…,9998]這行的數據做樣本來分析,我們來看一下V3算法的表現。

算法執行情況 結果
樣本 [0 – 10000] 的亂序數組
算法 V3 執行的總次數 19995
算法 V3 運行 100 次的平均時間 1 ms
運行時間與 V3 亂序樣例對比 V3 運行時間減少 99.96 %
執行次數與 V3 亂序樣例對比 V3 運行次數減少 99.29 %

可以看到,提升非常明顯。

5.4 適用情況

當冒泡算法運行到後半段的時候,如果此時數組已經有序了,需要提前結束冒泡排序。V3針對這樣的情況就特別有效。

6. 算法V4

嗯,什麼?為什麼不是結束語?那是因為還有一種沒有考慮到啊。

6.1 適用情況總結

我們總結一下前面的算法能夠處理的情況。

  • V1:正常亂序數組
  • V2:正常亂序數組,但對算法的執行次數做了優化
  • V3:大部分元素已經有序的數組,可以提前結束冒泡排序

還有一種情況是冒泡算法的輪數沒有執行完,甚至還沒有開始執行,後半段的數組就已經有序的數組,例如如下的情況。

這種情況,在數組完全有序之前都不會觸發V3中的提前停止算法,因為每一輪都有交換存在,flag的值會一直是true。而下標2之後的所有的數組都是有序的,算法會依次的冒泡完所有的已有序部分,造成資源的浪費。我們怎麼來處理這種情況呢?

6.2 實現分析

我們可以在V3的基礎之上來做。

當第一輪冒泡排序結束后,元素3會被移動到下標2的位置。在此之後沒有再進行過任意一輪的排序,但是如果我們不做處理,程序仍然會繼續的運行下去。

我們在V3的基礎上,加上一個標識endIndex來記錄這一輪最後的發生交換的位置。這樣一來,下一輪的冒泡就只冒到endIndex所記錄的位置即可。因為後面的數組沒有發生任何的交換,所以數組必定有序。

6.3 代碼實現

private void bubbleSort(int[] arr) {
  int endIndex = arr.length - 1;
  for (int i = 0; i < arr.length - 1; i++) {
    boolean flag = true;
    int endAt = 0;
    for (int j = 0; j < endIndex; j++) {
      if (arr[j] > arr[j + 1]) {
        flag = false;
        endAt = j;
        exchange(arr, j, j + 1);
      }
    }
    endIndex = endAt;
    if (flag) {
      break;
    }
  }
}

private void exchange(int arr[], int i, int j) {
  int temp = arr[i];
  arr[i] = arr[j];
  arr[j] = temp;
}

int[] arr = new int[]{5, 1, 3, 7, 6, 2, 4};
bubbleSort(arr);
System.out.println(Arrays.toString(arr)); // [1, 2, 3, 4, 5, 6, 7]

7. 算法V5

這一節仍然不是結束語…

7.1 算法優化

我們來看一下這種情況。

對於這種以上的算法都將不能發揮其應有的作用。每一輪算法都存在元素的交換,同時,直到算法完成以前,數組都不是有序的。但是如果我們能直接從右向左冒泡,只需要一輪就可以完成排序。這就是雞尾酒排序,冒泡排序的另一種優化,其適用情況就是上圖所展示的那種。

7.2 代碼實現

private void bubbleSort(int[] arr) {
  int leftBorder = 0;
  int rightBorder = arr.length - 1;

  int leftEndAt = 0;
  int rightEndAt = 0;

  for (int i = 0; i < arr.length / 2; i++) {
    boolean flag = true;
    for (int j = leftBorder; j < rightBorder; j++) {
      if (arr[j] > arr[j + 1]) {
        flag = false;
        exchange(arr, j, j + 1);
        rightEndAt = j;
      }
    }
    rightBorder = rightEndAt;
    if (flag) {
      break;
    }

    flag = true;
    for (int j = rightBorder; j > leftBorder; j--) {
      if (arr[j] < arr[j - 1]) {
        flag = false;
        exchange(arr, j, j - 1);
        leftEndAt = j;
      }
    }
    leftBorder = leftEndAt;
    if (flag) {
      break;
    }
  }
}

private void exchange(int arr[], int i, int j) {
  int temp = arr[i];
  arr[i] = arr[j];
  arr[j] = temp;
}

int[] arr = new int[]{2, 3, 4, 5, 6, 7, 1};
bubbleSort(arr);
System.out.println(Arrays.toString(arr)); // [1, 2, 3, 4, 5, 6, 7]

7.3 實現分析

第一層循環同樣用於控制總的循環輪數,由於每次需要從左到右再從右到左,所以總共的輪數是數組的長度 / 2。

內存循環則負責先實現從左到右的冒泡排序,再實現從右到左的冒泡,並且同時結合了V4的優化點。

我們來看一下V5與V4的對比。

算法執行情況 結果
樣本 [2,3,4…10000,1] 的數組
算法 V5 執行的總次數 19995
算法 V5 運行 100 次的平均時間 1 ms
運行時間與 V4 對比 V5 運行時間減少 99.97 %
執行次數與 V4 對比 V5 運行次數減少 99.34 %

8. 總結

以下是對同一個數組,使用每一種算法對其運行100次的平均時間和執行次數做的的對比。

[0 – 10000] 的亂序數組 V1 V2 V3 V4 V5
執行時間(ms) 184 142 143 140 103
執行次數(次) 99990000 49995000 49971129 49943952 16664191
大部分有序的情況 V1 V2 V3 V4 V5
執行時間(ms) 181 141 146 145 107
執行次數(次) 99990000 49995000 49993230 49923591 16675618

而冒泡排序的時間複雜度分為最好的情況和最快的情況。

  • 最好的情況為O($n$). 也就是我們在V5中提到的那種情況,數組2, 3, 4, 5, 6, 7, 1。使用雞尾酒算法,只需要進行一輪冒泡,即可完成對數組的排序。
  • 最壞的情況為O($n^2$).也就是V1,V2,V3和V4所遇到的情況,幾乎大部分數據都是無序的。

往期文章:

  • 聊聊微服務集群當中的自動化工具
  • go源碼解析-Println的故事
  • 用go-module作為包管理器搭建go的web服務器
  • WebAssembly完全入門——了解wasm的前世今身
  • 小強開飯店-從單體應用到微服務

相關:

  • 微信公眾號: SH的全棧筆記(或直接在添加公眾號界面搜索微信號LunhaoHu)

【精選推薦文章】

自行創業 缺乏曝光? 下一步"網站設計"幫您第一時間規劃公司的門面形象

網頁設計一頭霧水??該從何著手呢? 找到專業技術的網頁設計公司,幫您輕鬆架站!

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

台北網頁設計公司這麼多,該如何挑選?? 網頁設計報價省錢懶人包"嚨底家"

redis的五種數據類型及應用場景

前言

redis是用鍵值對的形式來保存數據,鍵類型只能是String,但是值類型可以有String、List、Hash、Set、Sorted Set五種,來滿足不同場景的特定需求。

本博客中的示例不是將控制台作為redis的一個客戶端,而是將redis運用在java里進行測試

需要有java redis的驅動包,可以通過引入maven的依賴即可

        <dependency>
            <groupId>org.rarefiedredis.redis</groupId>
            <artifactId>redis-java</artifactId>
            <version>0.0.17</version>
        </dependency>

 

String

String類型是最基礎的一種key-value存儲形式,value其實不僅僅可以是String,也可以是數值類型。常常用來做計數器這類自增自減的功能,可用在粉絲數、微博數等。

示例

 1         //連接本地的 Redis 服務
 2         Jedis jedis = new Jedis("localhost");
 3         System.out.println("連接成功");
 4         //查看服務是否運行
 5         System.out.println("服務正在運行: "+jedis.ping());
 6         //String實例
 7         jedis.set("hello", String.valueOf(1));
 8         jedis.incr("hello");
 9         jedis.set("hello1","word1");
10         System.out.println(jedis.get("hello"));
11         System.out.println(jedis.mget("hello","hello1"));

常用命令

  • set
  • get
  • mget
  • incr
  • decr

 

List

list就是鏈表,在redis實現為一個雙向鏈表,可以從兩邊插入、刪除數據。應用場景可以有微博的關注列表、粉絲列表、消息列表等。

有一個lrange函數,可以從某個元素開始讀取多少個元素,可用來實現分頁功能。

示例

 1         /*list實例,雙向鏈表結構,適合做消息隊列,
 2         但其實真正應用中一般都會用專門做消息隊列的中間件例如RabbitMQ*/
 3         jedis.lpush("201宿舍","hlf");
 4         jedis.lpush("201宿舍","css");
 5         jedis.lpush("201宿舍","ty");
 6         jedis.lpush("201宿舍","jy");
 7         List<String> name = jedis.lrange("201宿舍",0,3);
 8         for (String person:name
 9              ) {
10             System.out.print(person+" ");
11         }

 

常用命令

  •  lpush
  • rpush
  • lpush
  • lpop
  • lrange

 

Hash

hash就是值類型存儲的是一個鍵值對形式,適合存儲對象類型信息,例如個人信息、商品信息等。

示例

 1         //hash實例,適合存儲對象
 2         HashMap<String,String> map = new HashMap<String, String>();
 3         map.put("name","hlf");
 4         map.put("sex","女");
 5         map.put("age","21");
 6         jedis.hmset("hlf",map);
 7         jedis.hset("hlf","major","software");
 8         Map<String,String> map1 = jedis.hgetAll("hlf");
 9         String age = jedis.hget("hlf","age");
10         System.out.println(map1);
11         System.out.println(age);

 

常用命令

  • hset
  • hmset
  • hget
  • hgetAll

 

Set

set表示存儲的一個元素不重合的集合,因為set集合支持查緝、並集操作,因此適合做共同好友等功能

示例

1         //set實例
2         jedis.sadd("set","hhh");
3         jedis.sadd("set","ff");
4         jedis.sadd("set","hhh");
5         System.out.println(jedis.smembers("set"));
6         jedis.sadd("set1","oo");
7         jedis.sadd("set1","ff");
8         System.out.println("交集:"+jedis.sinter("set","set1"));
9         System.out.println("合集:"+jedis.sunion("set","set1"));

 

常用命令

  • sadd
  • spop
  • smembers
  • sunion
  • sinter

 

Sorted Set

相對於Set,Sorted Set多了一個Score作為權重,使集合裏面的元素可以按照score排序,注意它是Set,所以它裏面的元素也不能重複

示例

        //sorted set實例
        jedis.zadd("set2",4,"redis");
        jedis.zadd("set2",3,"mysql");
        jedis.zadd("set2",2,"kk");
        jedis.zadd("set2",1,"redis");
        System.out.println(jedis.zrangeByScore("set2",0,4));

 

常用命令

  • zadd
  • zpop
  • zrangeByScore

 

【精選推薦文章】

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

想知道網站建置、網站改版該如何進行嗎?將由專業工程師為您規劃客製化網頁設計及後台網頁設計

帶您來看台北網站建置台北網頁設計,各種案例分享

廣告預算用在刀口上,網站設計公司幫您達到更多曝光效益

高級Java工程師必備 —– 深入分析 Java IO (二)NIO

接着上一篇文章 高級Java工程師必備 —– 深入分析 Java IO (一)BIO,我們來講講NIO

多路復用IO模型

場景描述

一個餐廳同時有100位客人到店,當然到店后第一件要做的事情就是點菜。但是問題來了,餐廳老闆為了節約人力成本目前只有一位大堂服務員拿着唯一的一本菜單等待客人進行服務。

方法A: 無論有多少客人等待點餐,服務員都把僅有的一份菜單遞給其中一位客人,然後站在客人身旁等待這個客人完成點菜過程。在記錄客人點菜內容后,把點菜記錄交給後堂廚師。然後是第二位客人。。。。然後是第三位客人。很明顯,只有腦袋被門夾過的老闆,才會這樣設置服務流程。因為隨後的80位客人,再等待超時后就會離店(還會給差評)。

方法B: 老闆馬上新雇傭99名服務員,同時印製99本新的菜單。每一名服務員手持一本菜單負責一位客人(關鍵不只在於服務員,還在於菜單。因為沒有菜單客人也無法點菜)。在客人點完菜后,記錄點菜內容交給後堂廚師(當然為了更高效,後堂廚師最好也有100名)。這樣每一位客人享受的就是VIP服務咯,當然客人不會走,但是人力成本可是一個大頭哦(虧死你)。

方法C: 就是改進點菜的方式,當客人到店后,自己申請一本菜單。想好自己要點的才后,就呼叫服務員。服務員站在自己身邊後記錄客人的菜單內容。將菜單遞給廚師的過程也要進行改進,並不是每一份菜單記錄好以後,都要交給後堂廚師。服務員可以記錄號多份菜單后,同時交給廚師就行了。那麼這種方式,對於老闆來說人力成本是最低的;對於客人來說,雖然不再享受VIP服務並且要進行一定的等待,但是這些都是可接受的;對於服務員來說,基本上她的時間都沒有浪費,基本上被老闆壓桿了最後一滴油水。

到店情況:併發量。到店情況不理想時,一個服務員一本菜單,當然是足夠了。所以不同的老闆在不同的場合下,將會靈活選擇服務員和菜單的配置。
客人:客戶端請求
點餐內容:客戶端發送的實際數據
服務員:操作系統內核用於IO操作的線程(內核線程)
廚師:應用程序線程(當然廚房就是應用程序進程咯)
餐單傳遞方式:包括了阻塞式和非阻塞式兩種。

  • 方法A:阻塞式/非阻塞式 同步IO
  • 方法B:使用線程進行處理的 阻塞式/非阻塞式 同步IO
  • 方法C:阻塞式/非阻塞式 多路復用IO

多路復用IO技術最適用的是“高併發”場景,所謂高併發是指1毫秒內至少同時有上千個連接請求準備好。其他情況下多路復用IO技術發揮不出來它的優勢。另一方面,使用JAVA NIO進行功能實現,相對於傳統的Socket套接字實現要複雜一些,所以實際應用中,需要根據自己的業務需求進行技術選擇。

NIO

概念

JDK 1.4中的java.nio.*包中引入新的Java I/O庫,其目的是提高速度。實際上,“舊”的I/O包已經使用NIO重新實現過,即使我們不顯式的使用NIO編程,也能從中受益。速度的提高在文件I/O和網絡I/O中都可能會發生,但本文只討論後者。

NIO我們一般認為是New I/O(也是官方的叫法),因為它是相對於老的I/O類庫新增的(其實在JDK 1.4中就已經被引入了,但這個名詞還會繼續用很久,即使它們在現在看來已經是“舊”的了,所以也提示我們在命名時,需要好好考慮),做了很大的改變。但民間跟多人稱之為Non-block I/O,即非阻塞I/O,因為這樣叫,更能體現它的特點。而下文中的NIO,不是指整個新的I/O庫,而是非阻塞I/O。

面向流與面向緩衝

Java IO和NIO之間第一個最大的區別是,IO是面向流的,NIO是面向緩衝區的。 Java IO面向流意味着每次從流中讀一個或多個字節,直至讀取所有字節,它們沒有被緩存在任何地方。此外,它不能前後移動流中的數據。如果需要前後移動從流中讀取的數據,需要先將它緩存到一個緩衝區。

面向塊的 NIO一次處理一個數據塊,按塊處理數據比按流處理數據要快得多。數據讀取到一個它稍後處理的緩衝區,需要時可在緩衝區中前後移動。這就增加了處理過程中的靈活性。但是,還需要檢查是否該緩衝區中包含所有您需要處理的數據。而且,需確保當更多的數據讀入緩衝區時,不要覆蓋緩衝區里尚未處理的數據。

阻塞與非阻塞IO

Java IO的各種流是阻塞的。這意味着,當一個線程調用read() 或 write()時,該線程被阻塞,直到有一些數據被讀取,或數據完全寫入。該線程在此期間不能再干任何事情了。Java NIO的非阻塞模式,使一個線程從某通道發送請求讀取數據,但是它僅能得到目前可用的數據,如果目前沒有數據可用時,就什麼都不會獲取,而不是保持線程阻塞,所以直至數據變的可以讀取之前,該線程可以繼續做其他的事情。 非阻塞寫也是如此。一個線程請求寫入一些數據到某通道,但不需要等待它完全寫入,這個線程同時可以去做別的事情。 線程通常將非阻塞IO的空閑時間用於在其它通道上執行IO操作,所以一個單獨的線程現在可以管理多個輸入和輸出通道(channel)

通道

通道 Channel 是對原 I/O 包中的流的模擬,可以通過它讀取和寫入數據。

通道與流的不同之處在於,流只能在一個方向上移動(一個流必須是 InputStream 或者 OutputStream 的子類),而通道是雙向的,可以用於讀、寫或者同時用於讀寫。

通道包括以下類型:

  • FileChannel:從文件中讀寫數據;
  • DatagramChannel:通過 UDP 讀寫網絡中數據;
  • SocketChannel:通過 TCP 讀寫網絡中數據;
  • ServerSocketChannel:可以監聽新進來的 TCP 連接,對每一個新進來的連接都會創建一個 SocketChannel。

緩衝區

發送給一個通道的所有數據都必須首先放到緩衝區中,同樣地,從通道中讀取的任何數據都要先讀到緩衝區中。也就是說,不會直接對通道進行讀寫數據,而是要先經過緩衝區。

緩衝區實質上是一個數組,但它不僅僅是一個數組。緩衝區提供了對數據的結構化訪問,而且還可以跟蹤系統的讀/寫進程。

Buffer有兩種工作模式:寫模式和讀模式。在讀模式下,應用程序只能從Buffer中讀取數據,不能進行寫操作。但是在寫模式下,應用程序是可以進行讀操作的,這就表示可能會出現臟讀的情況。所以一旦您決定要從Buffer中讀取數據,一定要將Buffer的狀態改為讀模式。

注意:ServerSocketChannel通道它只支持對OP_ACCEPT事件的監聽,所以它是不能直接進行網絡數據內容的讀寫的。所以ServerSocketChannel是沒有集成Buffer的。

緩衝區包括以下類型:

  • ByteBuffer
  • CharBuffer
  • ShortBuffer
  • IntBuffer
  • LongBuffer
  • FloatBuffer
  • DoubleBuffer

 

 

可以用三個值指定緩衝區在任意時刻的狀態:

  • position
  • limit
  • capacity

Position

您可以回想一下,緩衝區實際上就是美化了的數組。在從通道讀取時,您將所讀取的數據放到底層的數組中。 position 變量跟蹤已經寫了多少數據。更準確地說,它指定了下一個字節將放到數組的哪一個元素中。因此,如果您從通道中讀三個字節到緩衝區中,那麼緩衝區的 position 將會設置為3,指向數組中第四個元素。

同樣,在寫入通道時,您是從緩衝區中獲取數據。 position 值跟蹤從緩衝區中獲取了多少數據。更準確地說,它指定下一個字節來自數組的哪一個元素。因此如果從緩衝區寫了5個字節到通道中,那麼緩衝區的 position 將被設置為5,指向數組的第六個元素。

Limit

limit 變量表明還有多少數據需要取出(在從緩衝區寫入通道時),或者還有多少空間可以放入數據(在從通道讀入緩衝區時)。

position 總是小於或者等於 limit

Capacity

緩衝區的 capacity 表明可以儲存在緩衝區中的最大數據容量。實際上,它指定了底層數組的大小 ― 或者至少是指定了准許我們使用的底層數組的容量。

limit 決不能大於 capacity

 

在實際操作數據時它們有如下關係圖:

① 新建一個大小為 8 個字節的緩衝區,此時 position 為 0,而 limit = capacity = 8。capacity 變量不會改變,下面的討論會忽略它。

② 從輸入通道中讀取 5 個字節數據寫入緩衝區中,此時 position 為 5,limit 保持不變。

③ 在將緩衝區的數據寫到輸出通道之前,需要先調用 flip() 方法,這個方法將 limit 設置為當前 position,並將 position 設置為 0。

④ 從緩衝區中取 4 個字節到輸出緩衝中,此時 position 設為 4。

⑤ 最後需要調用 clear() 方法來清空緩衝區,此時 position 和 limit 都被設置為最初位置。

 

文件複製 NIO 實例

以下展示了使用 NIO 快速複製文件的實例:

public static void fastCopy(String src, String dist) throws IOException {

    /* 獲得源文件的輸入字節流 */
    FileInputStream fin = new FileInputStream(src);

    /* 獲取輸入字節流的文件通道 */
    FileChannel fcin = fin.getChannel();

    /* 獲取目標文件的輸出字節流 */
    FileOutputStream fout = new FileOutputStream(dist);

    /* 獲取輸出字節流的文件通道 */
    FileChannel fcout = fout.getChannel();

    /* 為緩衝區分配 1024 個字節 */
    ByteBuffer buffer = ByteBuffer.allocateDirect(1024);

    while (true) {

        /* 從輸入通道中讀取數據到緩衝區中 */
        int r = fcin.read(buffer);

        /* read() 返回 -1 表示 EOF */
        if (r == -1) {
            break;
        }

        /* 切換讀寫 */
        buffer.flip();

        /* 把緩衝區的內容寫入輸出文件中 */
        fcout.write(buffer);

        /* 清空緩衝區 */
        buffer.clear();
    }
}

選擇器

NIO 常常被叫做非阻塞 IO,主要是因為 NIO 在網絡通信中的非阻塞特性被廣泛使用。

NIO 實現了 IO 多路復用中的 Reactor 模型,一個線程 Thread 使用一個選擇器 Selector 通過輪詢的方式去監聽多個通道 Channel 上的事件,從而讓一個線程就可以處理多個事件。

通過配置監聽的通道 Channel 為非阻塞,那麼當 Channel 上的 IO 事件還未到達時,就不會進入阻塞狀態一直等待,而是繼續輪詢其它 Channel,找到 IO 事件已經到達的 Channel 執行。

例如,當多個客戶端通過通道向服務端傳輸數據時,是通過 ByteBuffer 來傳輸,一個文件通過多次,從輸入通道中讀取 N 個字節數據寫入ByteBuffer,然後再將將緩衝區的數據寫到輸出通道,這個過程可以看成是不連續的,因為只有當緩衝區寫滿后,通過 buffer.flip() 切換成讀模式后,才開始向輸出通道寫入,所以當ByteBuffer還在寫入狀態時,服務器是不會等待這個通道的ByteBuffer寫滿,而是去處理其他客戶端Channel 為可讀的狀態,當然這個處理業務的工作可以開啟多線程來處理。

因為創建和切換線程的開銷很大,因此使用一個線程來處理多個事件而不是一個線程處理一個事件,對於 IO 密集型的應用具有很好地性能。

應該注意的是,只有套接字 Channel 才能配置為非阻塞,而 FileChannel 不能,為 FileChannel 配置非阻塞也沒有意義。

套接字 NIO 實例

package com.chenhao.nio;

import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.SelectionKey;
import java.nio.channels.Selector;
import java.nio.channels.ServerSocketChannel;
import java.nio.channels.SocketChannel;
import java.util.Date;
import java.util.Iterator;
import java.util.Scanner;

import org.junit.Test;

/*
 * 一、使用 NIO 完成網絡通信的三個核心:
 * 
 * 1. 通道(Channel):負責連接
 *         
 *        java.nio.channels.Channel 接口:
 *             |--SelectableChannel
 *                 |--SocketChannel
 *                 |--ServerSocketChannel
 *                 |--DatagramChannel
 * 
 * 2. 緩衝區(Buffer):負責數據的存取
 * 
 * 3. 選擇器(Selector):是 SelectableChannel 的多路復用器。用於監控 SelectableChannel 的 IO 狀況
 * 
 */
public class TestNonBlockingNIO {
    
    //客戶端
    @Test
    public void client() throws IOException{
        //1. 獲取通道
        SocketChannel sChannel = SocketChannel.open(new InetSocketAddress("127.0.0.1", 9898));
        
        //2. 切換非阻塞模式
        sChannel.configureBlocking(false);
        
        //3. 分配指定大小的緩衝區
        ByteBuffer buf = ByteBuffer.allocate(1024);
        
        //4. 發送數據給服務端
        Scanner scan = new Scanner(System.in);
        
        while(scan.hasNext()){
            String str = scan.next();
            buf.put((new Date().toString() + "\n" + str).getBytes());
            buf.flip();
            sChannel.write(buf);
            buf.clear();
        }
        
        //5. 關閉通道
        sChannel.close();
    }

    //服務端
    @Test
    public void server() throws IOException{
        //1. 獲取通道
        ServerSocketChannel ssChannel = ServerSocketChannel.open();
        
        //2. 切換非阻塞模式
        ssChannel.configureBlocking(false);
        
        //3. 綁定連接
        ssChannel.bind(new InetSocketAddress(9898));
        
        //4. 獲取選擇器
        Selector selector = Selector.open();
        
        //5. 將通道註冊到選擇器上, 並且指定“監聽接收事件”
        ssChannel.register(selector, SelectionKey.OP_ACCEPT);
        
        //6. 輪詢式的獲取選擇器上已經“準備就緒”的事件
        //使用 select() 來監聽到達的事件,它會一直阻塞直到有至少一個事件到達。
        while(selector.select() > 0){
            
            //7. 獲取當前選擇器中所有註冊的“選擇鍵(已就緒的監聽事件)”
            Iterator<SelectionKey> it = selector.selectedKeys().iterator();
            
            while(it.hasNext()){
                //8. 獲取準備“就緒”的是事件
                SelectionKey sk = it.next();
                
                //9. 判斷具體是什麼事件準備就緒
                if(sk.isAcceptable()){
                    //10. 若“接收就緒”,獲取客戶端連接
                    SocketChannel sChannel = ssChannel.accept();
                    
                    //11. 切換非阻塞模式
                    sChannel.configureBlocking(false);
                    
                    //12. 將該通道註冊到選擇器上
                    sChannel.register(selector, SelectionKey.OP_READ);
                }else if(sk.isReadable()){
                    //13. 獲取當前選擇器上“讀就緒”狀態的通道
                    SocketChannel sChannel = (SocketChannel) sk.channel();
                    
                    //14. 讀取數據
                    ByteBuffer buf = ByteBuffer.allocate(1024);
                    
                    int len = 0;
                    while((len = sChannel.read(buf)) > 0 ){
                        buf.flip();
                        System.out.println(new String(buf.array(), 0, len));
                        buf.clear();
                    }
                }
                
                //15. 取消選擇鍵 SelectionKey
                //每一個“事件關鍵字”被處理后都必須移除,否則下一次輪詢時,這個事件會被重複處理
                it.remove();
            }
        }
    }
}

NIO傳輸文件

服務器端代碼

public class Server {
    private ByteBuffer buffer = ByteBuffer.allocate(1024*1024);
        //使用Map保存每個連接,當OP_READ就緒時,根據key找到對應的文件對其進行寫入。若將其封裝成一個類,作為值保存,可以再上傳過程中显示進度等等
    Map<SelectionKey, FileChannel> fileMap = new HashMap<SelectionKey, FileChannel>();
    public static void main(String[] args) throws IOException{
        Server server = new Server();
        server.startServer();
    }
    public void startServer() throws IOException{
        Selector selector = Selector.open();
        ServerSocketChannel serverChannel = ServerSocketChannel.open();
        serverChannel.configureBlocking(false);
        serverChannel.bind(new InetSocketAddress(8888));
        serverChannel.register(selector, SelectionKey.OP_ACCEPT);
        System.out.println("服務器已開啟...");
        while (true) {
            int num = selector.select();
            if (num == 0) continue;
            Iterator<SelectionKey> it = selector.selectedKeys().iterator();
            while (it.hasNext()) {
                SelectionKey key = it.next();
                if (key.isAcceptable()) {
                    ServerSocketChannel serverChannel1 = (ServerSocketChannel) key.channel();
                    SocketChannel socketChannel = serverChannel1.accept();
                    if (socketChannel == null) continue;
                    socketChannel.configureBlocking(false);
                    SelectionKey key1 = socketChannel.register(selector, SelectionKey.OP_READ);
                    InetSocketAddress remoteAddress = (InetSocketAddress)socketChannel.getRemoteAddress();
                    File file = new File(remoteAddress.getHostName() + "_" + remoteAddress.getPort() + ".txt");
                    FileChannel fileChannel = new FileOutputStream(file).getChannel();
                    fileMap.put(key1, fileChannel);
                    System.out.println(socketChannel.getRemoteAddress() + "連接成功...");
                    writeToClient(socketChannel);
                }
                else if (key.isReadable()){
                    readData(key);
                }
                // NIO的特點只會累加,已選擇的鍵的集合不會刪除,ready集合會被清空
                // 只是臨時刪除已選擇鍵集合,當該鍵代表的通道上再次有感興趣的集合準備好之後,又會被select函數選中
                it.remove();
            }
        }
    }
    private void writeToClient(SocketChannel socketChannel) throws IOException {
        buffer.clear();
        buffer.put((socketChannel.getRemoteAddress() + "連接成功").getBytes());
        buffer.flip();
        socketChannel.write(buffer);
        buffer.clear();
    }
    private void readData(SelectionKey key) throws IOException  {
        FileChannel fileChannel = fileMap.get(key);
        buffer.clear();
        SocketChannel socketChannel = (SocketChannel) key.channel();
        int num = 0;
        try {
            while ((num = socketChannel.read(buffer)) > 0) {
                buffer.flip();
                // 寫入文件
                fileChannel.write(buffer);
                buffer.clear();
                }
        } catch (IOException e) {
            key.cancel();
            e.printStackTrace();
            return;
        }
        // 調用close為-1 到達末尾
        if (num == -1) {
            fileChannel.close();
            System.out.println("上傳完畢");
            buffer.put((socketChannel.getRemoteAddress() + "上傳成功").getBytes());
            buffer.clear();
            socketChannel.write(buffer);
            key.cancel();
        }
    }
}

 

客戶端模擬三個客戶端同時向服務器發送文件

public class Client {
    public static void main(String[] args) {
        for (int i = 0; i < 3; i++) {
            // 模擬三個發端
            new Thread() {
                public void run() {
                    try {
                        SocketChannel socketChannel = SocketChannel.open();
                        socketChannel.socket().connect(new InetSocketAddress("127.0.0.1", 8888));
                        File file = new File("E:\\" + 11 + ".txt");
                        FileChannel fileChannel = new FileInputStream(file).getChannel();
                        ByteBuffer buffer = ByteBuffer.allocate(100);
                        socketChannel.read(buffer);
                        buffer.flip();
                        System.out.println(new String(buffer.array(), 0, buffer.limit(), Charset.forName("utf-8")));
                        buffer.clear();
                        int num = 0;
                        while ((num=fileChannel.read(buffer)) > 0) {
                            buffer.flip();                        
                            socketChannel.write(buffer);
                            buffer.clear();
                        }
                        if (num == -1) {
                            fileChannel.close();
                            socketChannel.shutdownOutput();
                        }
                        // 接受服務器
                        socketChannel.read(buffer);
                        buffer.flip();
                        System.out.println(new String(buffer.array(), 0, buffer.limit(), Charset.forName("utf-8")));
                        buffer.clear();
                        socketChannel.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                    
                };
            }.start();
            
        }
        Thread.yield();
    }
}

可見這裏我們僅僅使用了一個線程就管理了三個連接,相比以前使用阻塞的Socket要在accept函數返回后開啟線程來管理這個連接,而使用NIO我們在accept返回后,僅僅將其註冊到選擇器上,讀操作在下次檢測到有可讀的鍵的集合時就會去處理。

NIO+線程池改進

public class ThreadPoolServer extends Server{
    private ExecutorService exec = Executors.newFixedThreadPool(10);
    public static void main(String[] args) throws IOException {
        ThreadPoolServer server = new ThreadPoolServer();
        server.startServer();
    }

    @Override
    protected void readData(final SelectionKey key) throws IOException {
        // 移除掉這個key的可讀事件,已經在線程池裡面處理,如果不改變當前Key的狀態,這裏交給另外一個線程去處理,主線程下一次遍歷此KEY還是可讀事件,會重複開啟線程處理任務
        key.interestOps(key.interestOps() & (~SelectionKey.OP_READ));
        exec.execute(new Runnable() {
            @Override
            public void run() {
                ByteBuffer buffer = ByteBuffer.allocate(1024 * 1024);
                FileChannel fileChannel = fileMap.get(key);
                buffer.clear();
                SocketChannel socketChannel = (SocketChannel) key.channel();
                int num = 0;
                try {
                    while ((num = socketChannel.read(buffer)) > 0) {
                        buffer.flip();
                        // 寫入文件
                        fileChannel.write(buffer);
                        buffer.clear();
                    }
                } catch (IOException e) {
                    key.cancel();
                    e.printStackTrace();
                    return;
                }
                // 調用close為-1 到達末尾
                if (num == -1) {
                    try {
                        fileChannel.close();
                        System.out.println("上傳完畢");
                        buffer.put((socketChannel.getRemoteAddress() + "上傳成功").getBytes());
                        buffer.clear();
                        socketChannel.write(buffer);
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                    // 只有調用cancel才會真正從已選擇的鍵的集合裏面移除,否則下次select的時候又能得到
                    // 一端close掉了,其對端仍然是可讀的,讀取得到EOF,返回-1
                    key.cancel(); 
                    return;
                }
                // Channel的read方法可能返回0,返回0並不一定代表讀取完了。
                // 工作線程結束對通道的讀取,需要再次更新鍵的ready集合,將感興趣的集合重新放在裏面
                key.interestOps(key.interestOps() | SelectionKey.OP_READ);
                // 調用wakeup,使得選擇器上的第一個還沒有返回的選擇操作立即返回即重新select
                key.selector().wakeup();
            }
        });
    }
}

推薦博客

  程序員寫代碼之外,如何再賺一份工資?

多路復用IO的優缺點

  • 不用再使用多線程來進行IO處理了(包括操作系統內核IO管理模塊和應用程序進程而言)。當然實際業務的處理中,應用程序進程還是可以引入線程池技術的
  • 同一個端口可以處理多種協議,例如,使用ServerSocketChannel的服務器端口監聽,既可以處理TCP協議又可以處理UDP協議。
  • 操作系統級別的優化:多路復用IO技術可以是操作系統級別在一個端口上能夠同時接受多個客戶端的IO事件。同時具有之前我們講到的阻塞式同步IO和非阻塞式同步IO的所有特點。Selector的一部分作用更相當於“輪詢代理器”。

【精選推薦文章】

如何讓商品強力曝光呢? 網頁設計公司幫您建置最吸引人的網站,提高曝光率!!

想要讓你的商品在網路上成為最夯、最多人討論的話題?

網頁設計公司推薦更多不同的設計風格,搶佔消費者視覺第一線

不管是台北網頁設計公司台中網頁設計公司,全省皆有專員為您服務

想知道最厲害的台北網頁設計公司推薦台中網頁設計公司推薦專業設計師"嚨底家"!!

余承東:華為手機優先用安卓,遷移鴻蒙OS只需1-2天

   網易科技訊,8 月 9 日消息,華為消費者業務首屆開發者大會今日舉行。華為首次公布了自研操作系統“鴻蒙”。余承東表示, 手機會優先安卓系統,但如果不能用, 隨時可以啟用鴻蒙,從安卓系統遷移到鴻蒙 OS 非常便捷,只需1-2 天。

  據余承東介紹,OS 鴻蒙基於微內核,具有全場景,分佈式等特性,實現手機、PC、平板、智慧大屏、車機等跨終端無縫協同體驗。

   余承東演講中稱,“很多人問我鴻蒙能不能使用在手機上,當然可以,我們隨時可以啟用鴻蒙。安卓系統如果不能使用,我們將安卓系統遷移到鴻蒙 OS 非常便捷,只需1-2 天即可實現。但考慮到生態和合作夥伴我們手機會優先安卓系統。”(崔玉賢)

【精選推薦文章】

帶您來了解什麼是 USB CONNECTOR  ?

為什麼 USB CONNECTOR 是電子產業重要的元件?

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

特斯拉遭車主集體訴訟:軟件升級後續航里程縮減

  美國電動車特斯拉是一家在行業和消費者中頗具爭議的公司,之前已經遭到了許多的消費者訴訟,其中涉及到自動駕駛系統造成的致死車禍。據媒體最新消息,日前,特斯拉公司的一位車主對這家電動汽車製造商提起訴訟,聲稱該公司通過軟件更新限制了已銷售車輛的電池續航里程,特斯拉目的是避免代價高昂的召回事件(用以解決原告聲稱有缺陷的電池問題)。

  據媒體報道,周三,原告在北加利福尼亞州聯邦法院提起訴訟,指控特斯拉欺詐行為,並尋求訴訟列為集體訴訟,代表世界各地受到影響“數千名”Model X 和 Model S 車主。

  據悉,許多上述兩款豪華電動車的車主發現他們的老一代電池的續航里程突然縮減,損失了 40 英里(64 公里)。自 5 月以來,續航里程縮短一直是特斯拉車主網絡論壇上的一個熱門話題,例如 TeslaMotorsClub.com,其中許多車主詳細說明他們的電池電量和續航里程如何下降。

  用戶表示特斯拉已經通過軟件更新取消了他們支付額外費用增加的電池續航里程,從而使汽車貶值,限制了他們可以旅行的距離並迫使他們更頻繁地充電。

  原告在訴狀中表示,原告大衛·拉斯穆森的 2014 款 Model S 85 車型電池容量在軟件升級后,損失了約 8 千瓦時的電量,但特斯拉公司卻告訴他說,這種下降是正常的。

  面對車主發起集體訴訟的報道,特斯拉公司周四沒有立即回應評論請求。

  據媒體報道,5 月,一輛特斯拉 Model S 電動車在中國香港發生起火燃燒,特斯拉隨後表示,出於謹慎,該公司正在通過遠程軟件更新修改 Model X 和 Model S 兩款車型的充電和熱管理設置。特斯拉這樣做的目標是“幫助進一步保護電池並延長電池使用壽命”。

  一個月後,特斯拉表示,只有一小部分車主受到電池續航里程減少的影響,並表示計劃改善軟件升級帶來的影響,同時特斯拉也表示充電行為是基於多種因素變化的。

  根據車主論壇的帖子,一些特斯拉車主發現,無法對電池進行百分之百的充電,這些車主已通過仲裁尋求補救措施,而至少有三個用戶因為這個問題變賣了特斯拉電動車。

  還有的特斯拉車主禁用其 Wi-Fi,以避免任何可能影響其續航里程的軟件更新。

  原告在訴狀中表示,特斯拉以安全和增加車輛電池壽命作為幌子,欺騙性地升級其軟件,意圖避免其責任和法律義務(即讓客戶修理,修理或更換電池)。

  原告認為,特斯拉公司知道訴訟涉及的電動車都有缺陷,但沒有告知客戶這些缺陷。

  原告還指出指出最近一連串的特斯拉電動車電池燃燒事件,並聲稱該公司沒有告知其客戶潛在的火災風險,而是“選擇在背後使用軟件更新和電池限制以避免責任”。

  在其網站上公布的車輛安全報告中,特斯拉表示,電動車燃燒起火“非常罕見”,從 2012 年到 2018 年,每 1.7 億英里的行駛距離大約有一輛特斯拉車輛起火。該公司與美國國家消防協會和美國交通部的數據進行了比較,显示美國普通車輛每 1900 萬英里行駛發生一次車輛起火。這些機構統計了所有車輛的火災,而不僅僅是特斯拉。

  今年 5 月,特斯拉稱其車輛遭遇火災的可能性比汽油車低 10 倍。它說,在調查中國香港的電動車燃燒事件時,發現只有少數電池模塊受到影響,而且大部分電池組都沒有損壞。

  特斯拉車主——美國佛羅里達州奧蘭多市的一位老闆尼克·史密斯在接受採訪時表示,他對特斯拉的客戶服務質量不佳感到沮喪,稱特斯拉工作人員對他的電話和电子郵件反應遲鈍,對所反映問題的真正根源一無所知,也不清楚該如何對問題進行補救。

  史密斯在接受採訪時說:“就好像你把車開到修理店,你原來有一個 20 加侖的油箱,但現在變成了 10 加侖的油箱,這些變化沒有經過你的同意和許可。”

  史密斯介紹說,在特斯拉進行軟件升級后,他的 2013 款 Model S P8 在充電到 90% 水平之後無法繼續充電。特斯拉告訴他,電池電量損失是由於正常的電池退化造成的。

  相關資料显示,特斯拉對於電動車電池提供八年保修。

【精選推薦文章】

平板收購,iphone手機收購,二手筆電回收,二手iphone收購-全台皆可收購

收購3c,收購IPHONE,收購蘋果電腦-詳細收購流程一覽表

高價3c回收,收購空拍機,收購鏡頭,收購 MACBOOK-更多收購平台討論專區

3c收購,鏡頭 收購有可能以全新價回收嗎?

賣IPHONE,iPhone回收,舊換新!教你怎麼賣才划算?

家裝指南:亂而過渡到美 成就亂的藝術

家裝指南:亂而過渡到美 成就亂的藝術

來自:www.zxdyw.com
日期:2009-08-24 11:50:12
很多人都會發現,在家居賣場一些看似隨意擺放的傢具都很漂亮,但是真正搬回家時,卻不一定有那個味道,同樣的道理,很多人看到樣板間里的傢具很漂亮,但是放到家裡卻感到一般,實際上這就是擺放的藝術。在家中亂要亂的有藝術性,如果隨意的擺放可以起到恰如其分的效果,就完全呼應主題了。

    電影橋段

  在失戀的打擊下,蘇菲的家似乎就沒有整潔過,凌亂的床、地毯、隨意擺放的傢具……但你注意過嗎,雖然很亂,但絲毫沒有讓人感到厭惡,相反讓人感到平實可親。亂得有美感,也很藝術。

  家裝看點

  把不同材質、不同顏色的傢具搭配起來,想着是不是會很亂?別急,亂也有講究,也可以亂得有章法,這就是搭配的妙處。

  完美,是我們每個人所追求的。裝修也是一樣,我們每個人對家都有夢想,只要你執着、努力,就會離自己的夢想更近一步,若還有意外驚喜,那就一定“非常完美”了。

  什麼是亂?什麼是美?如果非要把這兩種感覺放到一起,會不會有人說變態?其實,完全能做到以亂為美,關鍵看你要怎麼個亂法,如果亂得有章法、很藝術,那就一定會亂得很美!

  隨意不是隨便是生活氣息

  很多人都會發現,在家居賣場一些看似隨意擺放的傢具都很漂亮,但是真正搬回家時,卻不一定有那個味道,同樣的道理,很多人看到樣板間里的傢具很漂亮,但是放到家裡卻感到一般,實際上這就是擺放的藝術。設計師王秦說:“很多業主喜歡把家裡收拾得非常整齊,這樣雖然很好,但是卻少了幾分該有的溫馨,有點像賓館的感覺,就像剛做好的樣板間一樣,沒有‘人氣’。所謂的人氣就是生活的氣息,必須讓生活氣息走進居室,這樣空間才會靈動起來,才會真正有活力。當然人住進來免不了要放東西,那麼設計的難點就在於,既要讓客戶方便放東西,又要讓這些東西恰當地起到藝術化的擺放效果,這樣看似很亂的家才不會顯得真亂,而是生活氣息所在。”所以,在家中亂要亂的有藝術性,如果隨意的擺放可以起到恰如其分的效果,就完全呼應主題了。

  王秦稱,裝修時只要遵守至少一條規則就會有較好的效果和感受,比如相同的款式,相同的材質或是相同的顏色組合,這樣才能真正做到形散神不散,由亂而過渡到美,成就亂的藝術。

  混搭不是亂放是整體和諧

  一組沙發一般該是一種顏色吧?一般情況下是,但是在美克美家專賣店,很多沙發組合都是由不同顏色組成的,並且看上去相當和諧。銷售人員這樣介紹:“如果單獨來看這些沙發是有些亂的感覺,但實際上加上配飾,給它們之間一些簡單卻又巧妙的色彩聯繫,就如同一條條線一樣,把它們都整理並串起來了,所以不僅沒有亂的感覺,相反會讓人感到很親切。當然這些沙發的材質都是相同的,文章做在靠墊上,白色的搭上灰色的,灰色沙發配上白色靠墊,這樣自然也就把不同顏色沙發的關係拉近了。”

  此外,一些傢具看似隨意擺放,其實也是事先安排好的,最重要的是要起到空間平衡的作用,即講究對稱,傢具的多少最好能夠做到與空間的布局差不多,如果實在無法做到平衡,也要靠視覺遠近差異來弱化,或者可以通過顏色的明暗來調整。這樣,才能提升境界,真正從亂走向藝術,讓居室顯得和諧、美麗。

上述內容為轉載或編者觀點,不代表裝一網意見,不承擔任何法律責任。如侵權請聯繫刪除。


相關推薦

  • 美式裝修風格樣板間
  • 瓷磚美縫劑
  • 美甲店裝修
  • 美縫劑什麼牌子好

延伸閱讀

  • 告別家裡電線亂插亂放 全屋開關插座布置攻略
  • 傳統家裝亂象層出不窮 加速智能家裝革命性變革
  • 家裝行業拼價格難發展 市場亂象叩問新出路
  • 家居家裝行業服務規範11月完成 遏制亂象
  • 家裝建材保修期亂象生 維權可謂“蜀道難”
  • 2012年度建材行業亂象生 家裝專家支招2013市場
  • 空氣檢測市場亂象叢生 家裝網來揭秘祝君健康
  • 亂戰升級互聯網家裝痛點仍在 決勝互聯網戰場是重點
  • 用了E0級板材真的環保嗎?來看看E0級板材甲醛釋放量多少

  • 硅藻泥怎麼施工?五分鐘教你學會硅藻泥施工步驟

  • 進門鞋櫃怎麼裝修最合理?裝修網列舉圖片來說明

  • 5平米小餐廳怎麼裝修好看?裝修網分享餐廳裝修設計技巧

本站聲明:網站內容來源於裝修網http://www.zhuangyi.com/,如有侵權,請聯繫我們

【室內裝潢設計廠商推薦】

新屋購入,尋找台中室內設計師?是否可先免費估價丈量?

想要打造簡約、淡雅兼且收納空間的小資房,台中室內設計推薦哪一家?

中古屋大改造,分享台中室內設計公司隔間重新規劃,擴大實用空間!

裝修法則:新手飾家13個唯美家居裝飾愛家

裝修法則:新手飾家13個唯美家居裝飾愛家

來自:家天下
日期:2009-08-25 10:29:19
現代都市生活忙碌而緊張,一個溫暖的家能帶給每個人最放鬆的休閑時光。新手上路,都會覺得家居設計非常麻煩,不過看看下面的13個飾家方案,你會覺得,原來裝修也可以如此簡單!

    如何才能讓家變得溫暖舒適呢?只要掌握一些小技巧,就能輕鬆打造宜人家居。生活家小編為您準備了從房屋裝修到家居布置等一系列的時尚資訊,幫您擁有輕鬆舒適的生活。看看下面的13個飾家方案,你會覺得,原來裝修也可以如此簡單!

    1、白色夥伴

    搭配方案:用純白的傢具搭配明亮的淡紫色。顏色不要過於匹配:用些不同的顏色打破單調,比如嫩藍色的裝飾床頭板,或選用其它冷色調裝飾品。選用不多的暖色調裝飾品突出亮點。  

    2、體現出顏色層次

    搭配方案:用明亮的白色來緩和過冷的藍色。選擇與牆壁顏色反差較大的裝飾品。如果你的房間是開放式,那麼下一間最好選擇同一色系的不同顏色作為主色調,體現層次感。  

    3、巧妙搭配

    搭配方案:購買一條帶有強衝擊色的地毯,比如圖中的個性地毯。選擇一種顏色最為裝飾品的主色調。這樣你想重新布置的時候,只需拿走靠包和裝飾品即可。自己動手畫藝術畫。在普通的白帆布上用兩種顏色畫出簡單的線條。

    4、混合之美

    搭配方案:花大錢買些顏色中性,質量上乘的傢具是很值得的。烙上你的印記:如果你喜歡鄉村風格,不妨選擇方格紋棉布窗帘和中國陶瓷作為裝飾。選擇線條流暢的傢具,擺設輕鬆隨意,圖中的花紋圖案地毯在視覺上起了銜接的作用。  

    5、亮色點綴

    搭配方案:將冷色運用在意想不到的地方,像圖中傳統座椅的紫色椅面。 

    6、大膽的組合

    搭配方案:家中各種元素雖然色調不同,但都要有均勻的飽和度。比如圖中藍色的牆面,黃色的傢具和紅色的靠墊,顏色都很純正、醒目。不同顏色要有序搭配:比如牆壁刷了冷色,那麼傢具和裝飾品就選擇暖色。深色的木頭茶几可以壓住浮躁的色調,或者將它刷成白色,營造鄉村海邊風格。

    7、色彩點綴

    搭配方案:夏天適合選用清爽的藍色,冬天適合暖洋洋的紅色或橘色。選用多種圖案:在同一色系的基調下選用不同花紋圖案的靠包。  

    8、烹飪色彩

    搭配方案:櫥櫃顏色最好保持白色調,方便日後重新裝修。在你決定只刷廚房一部分牆時,要選擇能夠抓人眼球的顏色。如果碗碟開放式擺放,注意它們的顏色要和牆面協調。 

    9、藍色卧室

    搭配方案:卧室適宜輕柔的冷色調,但要避免過冷過亮的顏色。

最好連天花板都刷上同一種顏色。選擇中性的棕色調搭配整體藍色。
    10、歡快且明亮

    搭配方案:選用活潑的色彩使沉悶的家居環境振奮起來。用醒目的顏色在純白的空間製造亮點。將亮色擴展,比如圖中選用柔和一些的黃綠色穿插其中。

    11、藍色好搭檔

    搭配方案:用自然質樸的竹簾調和誇張的藍色。在冷色中穿插使用暖色:比如黃色細條紋扶手沙發和格紋地毯。房間里的各種元素最好選用多種圖案:碎花的床頭板,條紋沙發以及格紋地毯。  

    12、暫時的固定

    搭配方案:用家裡的剩餘布料為枕墊做個漂亮的藍色外套。深藍色的沙發軟墊套沉穩大氣,與牆面遙相呼應。椅墊套的邊緣打了個漂亮的蝴蝶結,散發出浪漫的少女情懷。

    13、黑色和藍色

    搭配方案:選擇淺顏色與黑色搭配,深淺交錯,相得益彰。用白色藝術畫來平衡藍黑兩色。不用避諱使用黑色傢具,大膽搭配吧。

上述內容為轉載或編者觀點,不代表裝一網意見,不承擔任何法律責任。如侵權請聯繫刪除。


相關推薦

  • 美式裝修風格樣板間
  • 美甲店裝修
  • 瓷磚美縫劑
  • 客廳裝飾畫
  • 電錶箱裝飾畫
  • 客廳裝飾
  • 玄關裝飾畫
  • 美縫劑什麼牌子好
  • 智能家居
  • 什麼是智能家居
  • 智能家居品牌
  • 智能家居分類
  • 智能家居安裝
  • 智能家居布線方案
  • 家居風水布局
  • 家居風水擺設
  • 家居風水植物
  • 智能家居產品
  • 裝修風格
  • 裝修風格大全
  • 裝修風格分類
  • 裝修風格圖片
  • 裝修風格有哪些
  • 歐式裝修風格

延伸閱讀

  • 紅星美凱龍發布“愛家”宣傳片 呼喚“愛家意識”
  • 紅星美凱龍 2010愛家日之《愛家盛典》落幕
  • 紅星美凱龍發起“愛家行動”推出“愛家航班”
  • 家居裝飾窗帘選購三大法則 讓家格調高几個檔次
  • 美克美家第三屆“美家匯”家居設計賽落幕
  • 時尚草編家居飾品 裝飾您的愛家
  • 家居網教你打造實用地台 現代家居裝靚愛家
  • 裝修就愛中國風 100平現代中式混搭複式美家
  • 用了E0級板材真的環保嗎?來看看E0級板材甲醛釋放量多少

  • 硅藻泥怎麼施工?五分鐘教你學會硅藻泥施工步驟

  • 進門鞋櫃怎麼裝修最合理?裝修網列舉圖片來說明

  • 5平米小餐廳怎麼裝修好看?裝修網分享餐廳裝修設計技巧

本站聲明:網站內容來源於裝修網http://www.zhuangyi.com/,如有侵權,請聯繫我們

【磁磚設計與裝修美學相關資訊】

挑好磚一點都不難!馬賽克磚挑選眉角小撇步!

浴室設計小心機,利用馬賽克磁磚,放大你的浴室空間

想改變客廳裝潢風格嗎? 馬賽克拼貼打造溫馨鄉村風,教你如何運用馬賽克瓷磚自行DIY創作
 

時尚潮流個性 盤點最能讓80后掏荷包的家裝消費?

時尚潮流個性 盤點最能讓80后掏荷包的家裝消費?

來自:www.zxdyw.com
日期:2009-09-01 17:48:54
隨着“80后”從輕狂的一代不斷地蛻變為各個崗位的主力軍,現在他們正處在成家立業的好時期,這樣看來,在家居行業里他們已經無形中具有了巨大的消費潛力。有調查數據显示,2007年,“80后”僅佔主流裝飾公司裝修客戶的30%,2008年這一比例已上升至45%,2009年這一比例更是上升到60%。在面對這樣一個龐大的家裝消費群體,究竟什麼的家裝才能抓住他們的心?在本文中為你一一揭秘這些疑問。

            
              
                           

    NO1 鍾愛個性設計

  出鏡人物:周林 年齡:26歲

  周林在廣告公司做平面設計,是一個非常追求“新奇特”的時尚潮男。

    新家裝修,更是不拘一格。在家居設計中,他大膽地運用了鮮艷的紅色作牆面的顏色,紅色牆面具有浪漫、溫馨而甜蜜的感覺,能營造出富有激情的氛圍。這麼明媚的色彩他又配以粉白、粉藍的造型典雅細膩的傢具,更是營造出了一種甜美富有個性的氛圍,在材質上,他又選擇了硅藻泥、牆基布、液體壁紙等新品種,電視背景牆、床頭背景牆的牆面手繪也都是由他親手製成。

    NO2 家居喜選成品

  出鏡人物:劉濤 年齡:27歲

  劉濤的工作節奏很快,對於裝修他覺得能簡單就簡單,主要是實用而且環保,他還比較重視裝飾公司的售後服務。

    劉濤家以前的門、傢具、櫥櫃等都是由裝修工人現場手工製作的,樣式單一,既不美觀,質量也無保證。於是他選擇了擁有集成家居的龍發裝飾以及部分其他建材品牌。他覺得集成家居產品沒有定型的款式,可以根據自己喜好、房屋格局,設計出適合自己的款式。吊頂、櫥櫃、木門、衣帽間、傢具等建材產品,全部都可以在工廠定製再運到現場進行安裝,方便快捷,質量可靠。

    NO3 建材很小型

  出境人物:方玲玲 年齡:25歲

  90平米以下戶型房已經達到整個供應的70%,方玲玲就買下了一套83平米的房子。

    她是個心思細膩的女孩子,因此在選擇建材時,更多地傾向於選擇適合小戶型使用的產品,既精巧也實用。她了解到,目前很多廠家都推出了適用於小戶型的建材產品,如牆面磚規格已經縮小到了20厘米,馬桶長度由70厘米縮短到65厘米,櫥櫃、檯面進深由60厘米縮短至40厘米。此外,不斷“長”高的衣帽櫃、各種款式的推拉門等可以充分利用空間和節省空間的產品也在市場上頗為流行。

    NO4 裝修設計我有我主張

  出境人物:孫翔 年齡:24歲

  自己參與設計,讓80后自己的家居實用個性並存。

    孫翔是一個典型的80后,他給設計師的要求就是要按照自己的學歷背景、工作背景和興趣習慣來設計自己的家,他認為這是非常有必要的,比如可以在一個用做觀景台的小陽台上,做出一個隱蔽的藏書櫥,這樣既突顯了個性,有能方便家裡的收納,宜居。

上述內容為轉載或編者觀點,不代表裝一網意見,不承擔任何法律責任。如侵權請聯繫刪除。


相關推薦

  • 80平米裝修預算
  • 80平米裝修費用
  • 80后裝修風格
  • 陽台壁掛太陽能
  • 陽台壁掛太陽能熱水器

延伸閱讀

  • 巧用個性單品 打造獨特的80后時尚家居
  • 時尚另類地板 百搭潮流個性
  • 80后成消費主流 地板企業迎來80后消費團體新商機
  • 80后裝修追求個性化 “逼”家裝公司變身
  • 智能家居智能化家裝設計 引領家裝時尚新潮流
  • “整體家裝”成市場潮流 消費者/經銷商/企業共贏
  • 80后時尚達人最愛混搭裝修 絢麗色彩打造舒適時尚家
  • 盤點”80后”最中意的家居流行風格
  • 用了E0級板材真的環保嗎?來看看E0級板材甲醛釋放量多少

  • 硅藻泥怎麼施工?五分鐘教你學會硅藻泥施工步驟

  • 進門鞋櫃怎麼裝修最合理?裝修網列舉圖片來說明

  • 5平米小餐廳怎麼裝修好看?裝修網分享餐廳裝修設計技巧

本站聲明:網站內容來源於裝修網http://www.zhuangyi.com/,如有侵權,請聯繫我們

【居家裝修精選推薦】

想知道北部最多平價、庫存出清的家具工廠推薦在哪裡?

屬於你的居家品味,家具訂製工廠推薦與心得分享

打造北歐風,連設計師也極力讚許的古典家具推薦工廠

好評熱賣,復刻家具推薦首選口袋名單

裝潢省錢妙招,家具訂製推薦達人,教您省下不必要的裝潢

家具設計推薦設計師,評論常見十大居家設計風格
 

家裝消費你被“潛規則”了嗎?

家裝消費你被“潛規則”了嗎?

來自:www.zxdyw.com
日期:2009-09-02 08:56:48
近段時間,隨着裝修旺季的到來,家居圈子的各種活動特別密集。記者近日也充當了一回消費者,到展會及各種促銷活動現場看了看,發現一些消費“潛規則”正埋伏着,等消費者上套。與以往不同的是,消費者面對種種陷阱理智了許多,“抗風險”能力明顯增強。

  潛規則:促銷概念“虛晃一槍”
  提醒:撿便宜多問幾個“為什麼”

  “裝修送吊頂”,看着某公司打着這樣的優惠大旗,馬女士問現場的工作人員,“吊頂是什麼牌子的?”“送全屋嗎?”“安裝費收不收呢?”面對企業打出的各種營銷大旗,消費者不再盲目上前撿便宜,而是先分析,消費明顯理性許多。據馬女士介紹,之前朋友選擇了一家裝飾公司,就因為其提供的優惠力度大、送的東西多,但是到了後來才發現,裝修總額返出來的券還有許多限制,比如買公司主材展廳內的吊頂、瓷磚、衛浴,每項只能花幾百元,大頭的支出還得自己掏,選擇餘地還有限制,真不如不要這些優惠。“這次準備裝修前,就和朋友們打聽了,所有吃過的啞巴虧、走過的冤枉路,都力求避免,商家再拿那些虛概念是不那麼容易讓我們上當了。”一位消費者拿着小本本,記者看到上面滿是抄錄來的各種促銷措施。她建議消費者,即使自己沒有提前做足功課,當市場上的“便宜”降臨,自己應多問幾個“為什麼”,小心被商家虛晃一槍。

    潛規則:空談“設計”造預算
    提醒:扔掉華而不實,追求實用

     王丁丁已經裝修過一套房了,她說:“現在的資訊很發達,看看電視、翻翻雜誌,創意設計比比皆是,我自己也有自己的審美觀。一般去諮詢,設計師都會問預期花多少錢、家裡面積多少、喜歡怎樣風格,我覺得我的要求已經遠遠超過這些了,需要設計師有‘一針見血’的自述。”從對展會的“掃描結果”可以發現,家裝展上,無論各公司“鬧騰”得多歡,消費者都愈加理性,他們大都帶着對自己家裝修的期待和個人見解逛展會。
  一位李姓消費者就表示:“我已經了解了一些家裝的基礎知識,也有了一個靠譜兒的裝修預算,在這裏,我不想一上來就聽什麼報價、材料品牌之類的話,我就是希望能找到和自己志同道合的公司和設計師,把我的想法都實現。”
  “有時候,設計師沒有對業主進行區別對待,單純追求設計也會導致失敗。小區的窗戶本來就設計得很低,設計師還按照常規設計將陽台墊高出來一個地台,這樣無疑忽視了家裝的安全性,光圖表面光鮮。”正在裝修新房的李莉說。

    潛規則:基礎裝修只圖表面光
    提醒:多為日後維修更換提供便利

     消費者劉先生表示,由於他們不是第一次裝修了,所以比較看重基礎裝修的品質,沒什麼是用不壞的,而那些不太標準的工程表面上看是挺好,可實際維修和更換的時候就費勁了,還可能得拆了重做,所以,這次他們裝修就一定會警惕這種“表面光維修難”的工程。
  劉先生說,比如電線這種埋在牆裡的東西,能用的時候都挺好,但自己家書房有一個落地燈的插頭突然不好用了,檢測發現裏面的一條線老化,可問題是那一條軟管里不止走了一條線,是三條纏在一起的,所以,沒辦法修那個地方就不能再放燈了。同時,劉先生還表示,很多第二次、第三次裝修的人大多更傾向於對設計支付更多的費用,但是,那一定是建立在“令人滿意的”基礎工程之上的。

   潛規則:看似便宜限制多
    提醒:看清裝修套餐的菜單和贈送方式

      梁女士在接受採訪時說出了自己的擔憂:“現在幾乎所有的人都知道,套餐價格並不是實際裝修的發生價,工程中總有這樣那樣的增項,設計師會說明哪些是不含在套餐里的,但再列出那個菜單就繁瑣得不得了,有時還不能囊括全部。”由於她只想給房子做個簡單的裝修,所以,比較傾向於選擇套餐類的裝修方案,除了圖個總價低,還想省掉挑選建材的時間。
  但具體了解下來,梁女士感嘆:“這‘餐’不容易‘吃’啊,看似便宜,限制咋恁多哩。”像多數套餐的報價都只含有最基本的工藝,如廚衛鋪磚、刷牆等,要再做吊頂、石膏線等,都得加錢。此外,套餐所含的櫥櫃、門等多數都是有數量限制的,如每25平方米的房子含1個門、每50平方米含一米櫥櫃等。這樣的數量,普通家庭顯然不夠用,如果要求增加,那自然也得加錢。通常情況,簽訂合同后,如果不要裝修公司提供的主材,還不能全額退還款額。梁女士希望,裝修公司的套餐產品能再簡化一些、實在一點。這樣,消費者才能夠明白輕鬆選擇,也能避免今後一些糊塗的扯皮戰。

    潛規則:一提品位就拿追加費用說事兒
    提醒:力求在有限範圍內找出最佳方案

      不少有裝修經驗的人都知道,去諮詢,裝修公司最常問的是“你打算花多少錢”,然後,根據是否支付設計費、設計大概的花費,把消費者帶到某一個設計師前。“有品質的生活,就只能在預算範圍之內去設計、實現嗎?”消費者馬燕燕煩惱地問。還沒拿到新房鑰匙的時候就已經在打聽裝修的事兒了,所以,她對於裝修的風格、材料、預算等方面已經有了一些認識,她認為,現在對她來說,最重要的不是設計師拿着戶型圖估算價格,而是有沒有一個公司能夠給她提供一個自己喜歡又合理的生活方式,並且可以把她的想法有機地融合進去。
  有着同樣想法的80后女生劉星,更是一個DIY家裝“亢奮者”,“如今在雜誌、電視上都可以看到有創意、花費不多的風格設計,也許是一塊床單上了牆,成了床頭的壁紙化裝修效果;也許是舊物改造中,一個破易拉罐做成的鬼臉裝飾物;也許是買衣服後去掉的商標吊牌做成的裝飾框……這些花費不多,但品質上乘、環保且個性,為何在現實裝飾設計中很難實現?”劉星問,現在有這樣想法的人不少,因為很多人都在真正裝修的幾個月前就開始為裝修補課,跑建材城和家裝公司,各方面準備都比較充分了,而沒有確定簽哪個公司的重要原因就是,在自己預算限定的那個層次上,還沒有遇到一個可以打動自己的方案,“家裝公司能不能在有限範圍內提供最佳生活方案?”其實,這種生活方式的表達是很細微的,但細緻入微的設計考慮是很多家裝公司欠缺的。

上述內容為轉載或編者觀點,不代表裝一網意見,不承擔任何法律責任。如侵權請聯繫刪除。

延伸閱讀

  • 建材市場暗藏“貓膩” 消費者須警惕行業“潛規則”
  • 定製傢具不退換成潛規則 消費者“啞巴吃黃連”
  • 地板連登黑榜曝潛規則 消費者選購須注意
  • 10條裝修秘籍 教您讀懂家裝“潛規則”
  • 謹防家裝行業潛規則,陶瓷衛浴黑幕曝光
  • 施工隊潛規則曝光 “畸形家裝風”不可助長
  • 家裝公司潛規則揭秘 為儘快簽單做預算故意漏項
  • 業內自曝塗料品牌竄貨四大元兇 難防”潛規則”
  • 用了E0級板材真的環保嗎?來看看E0級板材甲醛釋放量多少

  • 硅藻泥怎麼施工?五分鐘教你學會硅藻泥施工步驟

  • 進門鞋櫃怎麼裝修最合理?裝修網列舉圖片來說明

  • 5平米小餐廳怎麼裝修好看?裝修網分享餐廳裝修設計技巧

本站聲明:網站內容來源於裝修網http://www.zhuangyi.com/,如有侵權,請聯繫我們

【裝潢房事討論區】

解決漏水、壁癌危機,找尋新竹舊屋翻新專業修繕專家

老舊房屋馬桶不通、水管阻塞,推薦竹北通水管新竹通水管專業師傅,徹底解決多年臭味問題

針對一般住家各種奇怪漏水問題,竹北水電東通水管修復作業案例揭密!

推薦竹東裝潢老師傅統包團隊,裝潢、修繕一次搞定!!